valkyrie-sequel 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 147de175c6560bcb1836553dd0c5c3e94908c5f8
+  data.tar.gz: e48b68150de3a5ed8efb8ac4064866db769227ee
+SHA512:
+  metadata.gz: 546160cf2ab0d62a4e2196bc8f390510999cc8e2e9e74e6aa3f483eec6c2f236b45103361d37c31f98d84cf4a45fbf4dd98cbe6cf389ad20aefe594eb7326a6f
+  data.tar.gz: 396c775f741c4d972e372c5400cd9f23236dac76c983e5d3183553726c745e3bf30be4dbf4dbb17e456d1ee29fbc8eaa551d0e3dc8f7d929e5bddd0629ab688c

data/.circleci/config.yml

@@ -0,0 +1,33 @@
+---
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.3.7-node-browsers
+        environment:
+          RAILS_ENV: test
+          DB_HOST: localhost
+          DB_USERNAME: valkyrie_sequel
+          DB_PASSWORD:  ""
+          DB_DATABASE: "valkyrie_sequel_test"
+      - image: postgres:10.3-alpine
+        environment:
+          POSTGRES_USER: valkyrie_sequel
+          POSTGRES_DB: valkyrie_sequel_test
+          POSTGRES_PASSWORD: ""
+    steps:
+      - checkout
+      # Restore Cached Dependencies
+      - type: cache-restore
+        name: Restore bundle cache
+        key: valkyrie-sequel-{{ checksum "Gemfile" }}
+      # Bundle install dependencies
+      - run: bundle install --path vendor/bundle
+      # Cache Dependencies
+      - type: cache-save
+        name: Store bundle cache
+        key: valkyrie-sequel-{{ checksum "Gemfile" }}
+        paths:
+          - vendor/bundle
+      - run: bundle exec rubocop
+      - run: bundle exec rspec spec

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,22 @@
+inherit_gem:
+  bixby: bixby_default.yml
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.3
+  Exclude:
+    - 'bin/*'
+    - 'db/schema.rb'
+    - 'vendor/**/*'
+Naming/FileName:
+  Exclude:
+    - 'valkyrie-sequel.gemspec'
+    - 'Gemfile'
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+Metrics/ClassLength:
+  Exclude:
+    - 'lib/valkyrie/sequel/query_service.rb'
+Metrics/ParameterLists:
+  Exclude:
+    - 'lib/valkyrie/sequel/metadata_adapter.rb'

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in valkyrie-sequel.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2018 Princeton University Library
+Additional copyright may be held by others, as reflected in the commit history. 
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,28 @@
+# Valkyrie::Sequel
+
+Valkyrie adapter for postgres using [Sequel](https://github.com/jeremyevans/sequel)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'valkyrie-sequel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install valkyrie-sequel
+
+## Running Specs
+
+1. Ensure Postgres is installed (`brew install postgresql` on Mac)
+2. If necessary, provide the environment variables DB_USERNAME, DB_PASSWORD,
+   DB_HOST, DB_PORT, and DB_DATABASE to the following commands. This should not be
+   necessary on a local development setup, though.
+3. `rake db:create`
+4. `rspec spec`

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+namespace :db do
+  task :environment do
+    require 'valkyrie/sequel'
+    require_relative 'spec/support/db_connection_info'
+  end
+  desc "Create Test Database"
+  task create: :environment do
+    connection = Sequel.connect(DB_CONNECTION_INFO.merge(adapter: :postgres, database: :postgres))
+    begin
+      connection.execute "CREATE DATABASE #{DB_CONNECTION_INFO[:database]}"
+      puts "Database #{DB_CONNECTION_INFO[:database]} created."
+    rescue Sequel::DatabaseError
+      puts "Database already exists"
+    end
+  end
+  desc "Drop Test Database"
+  task drop: :environment do
+    new_connection = Sequel.connect(DB_CONNECTION_INFO.merge(adapter: :postgres, database: :postgres))
+    new_connection.execute "DROP DATABASE IF EXISTS #{DB_CONNECTION_INFO[:database]}"
+    puts "#{DB_CONNECTION_INFO[:database]} dropped"
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "valkyrie/sequel"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrations/001_create_orm_resources.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+Sequel.migration do
+  up do
+    run 'CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'
+    create_table :orm_resources do
+      column :id, :uuid, default: Sequel.function(:uuid_generate_v4), primary_key: true
+      column :metadata, :jsonb, default: '{}', index: { type: :gin }
+      String :internal_resource, index: true
+      Integer :lock_version, index: true
+      DateTime :created_at, index: true, default: ::Sequel::CURRENT_TIMESTAMP
+      DateTime :updated_at, index: true
+    end
+    run 'CREATE INDEX orm_resources_metadata_index_pathops ON orm_resources USING gin (metadata jsonb_path_ops)'
+  end
+  down do
+    drop_table :orm_resources
+    run 'DROP EXTENSION "uuid-ossp"'
+  end
+end

data/lib/sequel/extensions/oj_parser.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'oj'
+module Sequel
+  def self.object_to_json(obj, *_args, &_block)
+    ::Oj.dump(obj.as_json)
+  end
+
+  def self.parse_json(json)
+    Oj.load(json, create_additions: false, mode: :compat)
+  end
+end

data/lib/valkyrie/sequel/metadata_adapter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  require 'valkyrie/sequel/resource_factory'
+  require 'valkyrie/sequel/query_service'
+  require 'valkyrie/sequel/persister'
+  class MetadataAdapter
+    attr_reader :connection
+    def initialize(connection:)
+      @connection = connection.tap do |conn|
+        conn.extension(:pg_json)
+        conn.extension(:pg_streaming)
+      end
+    end
+
+    def persister
+      @persister ||= Persister.new(adapter: self)
+    end
+
+    def query_service
+      @query_service ||= QueryService.new(adapter: self)
+    end
+
+    def resource_factory
+      @resource_factory ||= ResourceFactory.new(adapter: self)
+    end
+
+    def id
+      @id ||= begin
+        to_hash = "sequel://#{host}:#{port}:#{database}"
+        Valkyrie::ID.new(Digest::MD5.hexdigest(to_hash))
+      end
+    end
+
+    def perform_migrations!
+      Sequel.extension :migration
+      Sequel::Migrator.run(connection, "#{__dir__}/../../../db/migrations")
+    end
+
+    def reset_database!
+      Sequel.extension :migration
+      Sequel::Migrator.run(connection, "#{__dir__}/../../../db/migrations", target: 0)
+      perform_migrations!
+    end
+
+    def resources
+      connection.from(:orm_resources)
+    end
+
+    private
+
+      def host
+        connection.opts[:host]
+      end
+
+      def port
+        connection.opts[:port]
+      end
+
+      def database
+        connection.opts[:database]
+      end
+  end
+end

data/lib/valkyrie/sequel/persister.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  class Persister
+    attr_reader :adapter
+    delegate :resource_factory, to: :adapter
+    delegate :resources, :connection, to: :adapter
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def save(resource:)
+      object_attributes = resource_factory.from_resource(resource: resource)
+      output = create_or_update(resource: resource, attributes: object_attributes)
+      resource_factory.to_resource(object: output)
+    end
+
+    def save_all(resources:)
+      connection.transaction do
+        output = SaveAllPersister::Factory.new(persister: self).for(resources: resources).persist!
+        raise Valkyrie::Persistence::StaleObjectError, "One or more resources have been updated by another process." if output.length != resources.length
+        output.map do |object|
+          resource_factory.to_resource(object: object)
+        end
+      end
+    end
+
+    class SaveAllPersister
+      class Factory
+        delegate :adapter, to: :persister
+        delegate :resource_factory, to: :adapter
+        delegate :resources, to: :adapter
+        attr_reader :persister
+        def initialize(persister:)
+          @persister = persister
+        end
+
+        # Resources have to be handled differently based on whether or not
+        # optimistic locking is enabled. Splitting it into two upserts allows
+        # for faster save_all while still handling optimistic locking.
+        def for(resources:)
+          grouped_resources = resources.group_by(&:optimistic_locking_enabled?)
+          locked_resources = grouped_resources[true] || []
+          unlocked_resources = grouped_resources[false] || []
+          CompositePersister.new(
+            [
+              SaveAllPersister.new(resources: locked_resources, relation: locking_relation, resource_factory: resource_factory),
+              SaveAllPersister.new(resources: unlocked_resources, relation: relation, resource_factory: resource_factory)
+            ]
+          )
+        end
+
+        def relation
+          resources.returning.insert_conflict(
+            target: :id,
+            update: update_branches
+          )
+        end
+
+        # Locking relation has an update_where condition.
+        def locking_relation
+          resources.returning.insert_conflict(
+            target: :id,
+            update: update_branches,
+            update_where: { Sequel[:orm_resources][:lock_version] => Sequel[:excluded][:lock_version] }
+          )
+        end
+
+        def update_branches
+          {
+            metadata: Sequel[:excluded][:metadata],
+            internal_resource: Sequel[:excluded][:internal_resource],
+            lock_version: Sequel[:excluded][:lock_version] + 1,
+            created_at: Sequel[:excluded][:created_at],
+            updated_at: Time.now.utc
+          }
+        end
+      end
+      attr_reader :resources, :relation, :resource_factory
+      def initialize(resources:, relation:, resource_factory:)
+        @resources = resources
+        @relation = relation
+        @resource_factory = resource_factory
+      end
+
+      def persist!
+        return [] if resources.empty?
+        Array.wrap(
+          relation.multi_insert(converted_resources)
+        )
+      end
+
+      def converted_resources
+        @converted_resources ||= resources.map do |resource|
+          output = resource_factory.from_resource(resource: resource)
+          output[:lock_version] ||= 0
+          output[:created_at] ||= Time.now.utc
+          output[:updated_at] ||= Time.now.utc
+          output
+        end
+      end
+      class CompositePersister
+        attr_reader :persisters
+        def initialize(persisters)
+          @persisters = persisters
+        end
+
+        def persist!
+          persisters.flat_map(&:persist!)
+        end
+      end
+    end
+    def delete(resource:)
+      resources.where(id: resource.id.to_s).delete
+      resource
+    end
+
+    def wipe!
+      resources.delete
+    end
+
+    private
+
+      def create_or_update(resource:, attributes:)
+        attributes[:updated_at] = Time.now.utc
+        attributes[:created_at] ||= Time.now.utc
+        return create(resource: resource, attributes: attributes) unless resource.persisted? && !exists?(id: attributes[:id])
+        update(resource: resource, attributes: attributes)
+      end
+
+      def create(resource:, attributes:)
+        attributes[:lock_version] = 0 if resource.optimistic_locking_enabled? && resources.columns.include?(:lock_version)
+        Array(resources.returning.insert(attributes)).first
+      end
+
+      def update(resource:, attributes:)
+        relation = resources.where(id: attributes[:id])
+        if resource.optimistic_locking_enabled?
+          relation = relation.where(lock_version: attributes[:lock_version]) if attributes[:lock_version]
+          attributes[:lock_version] = (Sequel[:lock_version] + 1)
+        end
+        attributes.delete(:lock_version) if attributes[:lock_version].nil?
+        output = relation.returning.update(attributes)
+        raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." if output.blank? && resource.optimistic_locking_enabled?
+        Array(output).first
+      end
+
+      def exists?(id:)
+        resources.select(1).first(id: id).nil?
+      end
+  end
+end

data/lib/valkyrie/sequel/query_service.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  class QueryService
+    ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
+    attr_reader :adapter
+    delegate :resources, :resource_factory, :connection, to: :adapter
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def find_all
+      resources.use_cursor.lazy.map do |attributes|
+        resource_factory.to_resource(object: attributes)
+      end
+    end
+
+    def find_by(id:)
+      id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+      validate_id(id)
+      raise Valkyrie::Persistence::ObjectNotFoundError unless ACCEPTABLE_UUID.match?(id.to_s)
+      attributes = resources.first(id: id.to_s)
+      raise Valkyrie::Persistence::ObjectNotFoundError unless attributes
+      resource_factory.to_resource(object: attributes)
+    end
+
+    def find_all_of_model(model:)
+      resources.where(internal_resource: model.to_s).map do |attributes|
+        resource_factory.to_resource(object: attributes)
+      end
+    end
+
+    def find_many_by_ids(ids:)
+      ids = ids.map do |id|
+        id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+        validate_id(id)
+        id.to_s
+      end
+      ids = ids.select do |id|
+        ACCEPTABLE_UUID.match?(id)
+      end
+
+      resources.where(id: ids).map do |attributes|
+        resource_factory.to_resource(object: attributes)
+      end
+    end
+
+    def find_references_by(resource:, property:)
+      return [] if resource.id.blank? || resource[property].blank?
+      # only return ordered if needed to avoid performance penalties
+      if ordered_property?(resource: resource, property: property)
+        run_query(find_ordered_references_query, property.to_s, resource.id.to_s)
+      else
+        run_query(find_references_query, property.to_s, resource.id.to_s)
+      end
+    end
+
+    def find_inverse_references_by(resource: nil, id: nil, property:)
+      raise ArgumentError, "Provide resource or id" unless resource || id
+      ensure_persisted(resource) if resource
+      id ||= resource.id
+      internal_array = { property => [id: id.to_s] }
+      run_query(find_inverse_references_query, internal_array.to_json)
+    end
+
+    # Find and a record using a Valkyrie ID for an alternate ID, and construct
+    #   a Valkyrie Resource
+    # @param [Valkyrie::ID] alternate_identifier
+    # @return [Valkyrie::Resource]
+    def find_by_alternate_identifier(alternate_identifier:)
+      alternate_identifier = Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
+      validate_id(alternate_identifier)
+      internal_array = { alternate_ids: [{ id: alternate_identifier.to_s }] }
+      run_query(find_inverse_references_query, internal_array.to_json).first || raise(Valkyrie::Persistence::ObjectNotFoundError)
+    end
+
+    def find_members(resource:, model: nil)
+      return [] if resource.id.blank?
+      if model
+        run_query(find_members_with_type_query, resource.id.to_s, model.to_s)
+      else
+        run_query(find_members_query, resource.id.to_s)
+      end
+    end
+
+    def find_parents(resource:)
+      find_inverse_references_by(resource: resource, property: :member_ids)
+    end
+
+    # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
+    # @return [Valkyrie::Persistence::CustomQueryContainer]
+    def custom_queries
+      @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
+    end
+
+    def run_query(query, *args)
+      connection[query, *args].map do |result|
+        resource_factory.to_resource(object: result)
+      end
+    end
+
+    private
+
+      # Generate the SQL query for retrieving member resources in PostgreSQL using a
+      #   resource ID as an argument.
+      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+      # @note this uses a CROSS JOIN for all combinations of member IDs with the
+      #   IDs of their parents
+      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+      # This also uses JSON functions in order to retrieve JSON property values
+      # @see https://www.postgresql.org/docs/current/static/functions-json.html
+      # @return [String]
+      def find_members_query
+        <<-SQL
+          SELECT member.* FROM orm_resources a,
+          jsonb_array_elements(a.metadata->'member_ids') WITH ORDINALITY AS b(member, member_pos)
+          JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+          ORDER BY b.member_pos
+        SQL
+      end
+
+      # Generate the SQL query for retrieving member resources in PostgreSQL using a
+      #   resource ID and resource type as arguments.
+      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+      # @note this uses a CROSS JOIN for all combinations of member IDs with the
+      #   IDs of their parents
+      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+      # This also uses JSON functions in order to retrieve JSON property values
+      # @see https://www.postgresql.org/docs/current/static/functions-json.html
+      # @return [String]
+      def find_members_with_type_query
+        <<-SQL
+          SELECT member.* FROM orm_resources a,
+          jsonb_array_elements(a.metadata->'member_ids') WITH ORDINALITY AS b(member, member_pos)
+          JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+          AND member.internal_resource = ?
+          ORDER BY b.member_pos
+        SQL
+      end
+
+      # Generate the SQL query for retrieving member resources in PostgreSQL using a
+      #   JSON object literal as an argument (e. g. { "alternate_ids": [{"id": "d6e88f80-41b3-4dbf-a2a0-cd79e20f6d10"}] }).
+      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+      # This uses JSON functions in order to retrieve JSON property values
+      # @see https://www.postgresql.org/docs/current/static/functions-json.html
+      # @return [String]
+      def find_inverse_references_query
+        <<-SQL
+          SELECT * FROM orm_resources WHERE
+          metadata @> ?
+        SQL
+      end
+
+      # Generate the SQL query for retrieving member resources in PostgreSQL using a
+      #   JSON object literal and resource ID as arguments.
+      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+      # @note this uses a CROSS JOIN for all combinations of member IDs with the
+      #   IDs of their parents
+      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+      # This also uses JSON functions in order to retrieve JSON property values
+      # @see https://www.postgresql.org/docs/current/static/functions-json.html
+      # @return [String]
+      def find_references_query
+        <<-SQL
+          SELECT DISTINCT member.* FROM orm_resources a,
+          jsonb_array_elements(a.metadata->?) AS b(member)
+          JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+        SQL
+      end
+
+      def find_ordered_references_query
+        <<-SQL
+          SELECT member.* FROM orm_resources a,
+          jsonb_array_elements(a.metadata->?) WITH ORDINALITY AS b(member, member_pos)
+          JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
+          ORDER BY b.member_pos
+        SQL
+      end
+
+      # Accesses the data type in PostgreSQL used for the primary key
+      # (For example, a UUID)
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
+      # @return [Symbol]
+      def id_type
+        @id_type ||= :uuid
+      end
+
+      # Determines whether or not an Object is a Valkyrie ID
+      # @param [Object] id
+      # @raise [ArgumentError]
+      def validate_id(id)
+        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+      end
+
+      # Determines whether or not a resource has been persisted
+      # @param [Object] resource
+      # @raise [ArgumentError]
+      def ensure_persisted(resource)
+        raise ArgumentError, 'resource is not saved' unless resource.persisted?
+      end
+
+      def ordered_property?(resource:, property:)
+        resource.class.schema[property].meta.try(:[], :ordered)
+      end
+  end
+end

data/lib/valkyrie/sequel/resource_factory/orm_converter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  class ResourceFactory::ORMConverter
+    attr_reader :object, :resource_factory
+    def initialize(object, resource_factory:)
+      @object = object
+      @resource_factory = resource_factory
+    end
+
+    def convert!
+      @resource ||= resource
+    end
+
+    private
+
+      # Construct a new Valkyrie Resource using the attributes retrieved from the database
+      # @return [Valkyrie::Resource]
+      def resource
+        resource_klass.new(
+          attributes.merge(
+            new_record: false,
+            Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
+          )
+        )
+      end
+
+      # Construct the optimistic lock token using the adapter and lock version for the Resource
+      # @return [Valkyrie::Persistence::OptimisticLockToken]
+      def lock_token
+        @lock_token ||=
+          Valkyrie::Persistence::OptimisticLockToken.new(
+            adapter_id: resource_factory.adapter_id,
+            token: object[:lock_version]
+          )
+      end
+
+      # Retrieve the Class used to construct the Valkyrie Resource
+      # @return [Class]
+      def resource_klass
+        internal_resource.constantize
+      end
+
+      # Access the String for the Valkyrie Resource type within the attributes
+      # @return [String]
+      def internal_resource
+        attributes[:internal_resource]
+      end
+
+      def attributes
+        @attributes ||= object.except(:metadata).merge(rdf_metadata).symbolize_keys
+      end
+
+      # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
+      # @return [Hash]
+      def rdf_metadata
+        @rdf_metadata ||= Valkyrie::Persistence::Postgres::ORMConverter::RDFMetadata.new(object[:metadata]).result
+      end
+  end
+end

data/lib/valkyrie/sequel/resource_factory/resource_converter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  class ResourceFactory::ResourceConverter
+    attr_reader :resource, :resource_factory
+    delegate :orm_class, :adapter, to: :resource_factory
+    delegate :resources, to: :adapter
+    def initialize(resource, resource_factory:)
+      @resource = resource
+      @resource_factory = resource_factory
+    end
+
+    def convert!
+      output = database_hash
+      output[:id] = resource.id.to_s if resource.id
+      output.delete(:id) unless !output[:id] || QueryService::ACCEPTABLE_UUID.match?(output[:id].to_s)
+      process_lock_token(output)
+      output
+    end
+
+    private
+
+      # Retrieves the optimistic lock token from the Valkyrie attribute value and
+      #   sets it to the lock_version on ORM resource
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
+      # @param [ORM::Resource] orm_object
+      def process_lock_token(orm_object)
+        return unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
+        postgres_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find do |token|
+          token.adapter_id == resource_factory.adapter_id
+        end
+        return unless postgres_token
+        orm_object[:lock_version] = postgres_token.token
+      end
+
+      def database_hash
+        resource_hash.select do |k, _v|
+          primary_terms.include?(k)
+        end.compact.merge(
+          metadata: ::Sequel.pg_json(metadata_hash)
+        )
+      end
+
+      def resource_hash
+        @resource_hash ||= resource.to_h
+      end
+
+      # Convert attributes to all be arrays to better enable querying and
+      # "changing of minds" later on.
+      # @return [Hash]
+      def metadata_hash
+        Hash[
+          selected_resource_attributes.compact.map do |k, v|
+            [k, Array.wrap(v)]
+          end
+        ]
+      end
+
+      def selected_resource_attributes
+        resource_hash.select do |k, _v|
+          !primary_terms.include?(k) && !blacklist_terms.include?(k)
+        end
+      end
+
+      def primary_terms
+        [
+          :id,
+          :created_at,
+          :updated_at,
+          :internal_resource
+        ]
+      end
+
+      def blacklist_terms
+        [
+          :new_record
+        ]
+      end
+  end
+end

data/lib/valkyrie/sequel/resource_factory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Valkyrie::Sequel
+  class ResourceFactory
+    require 'valkyrie/sequel/resource_factory/resource_converter'
+    require 'valkyrie/sequel/resource_factory/orm_converter'
+    attr_reader :adapter
+    delegate :id, to: :adapter, prefix: true
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def to_resource(object:)
+      ORMConverter.new(object, resource_factory: self).convert!
+    end
+
+    def from_resource(resource:)
+      ResourceConverter.new(resource, resource_factory: self).convert!
+    end
+
+    def orm_class
+      adapter.resources
+    end
+  end
+end

data/lib/valkyrie/sequel/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Valkyrie
+  module Sequel
+    VERSION = "1.0.0"
+  end
+end

data/lib/valkyrie/sequel.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "valkyrie/sequel/version"
+require 'valkyrie'
+require 'sequel'
+require 'sequel/adapters/postgresql'
+require 'sequel_pg'
+
+module Valkyrie
+  module Sequel
+    ::Sequel.extension(:pg_json)
+    ::Sequel.extension(:pg_json_ops)
+    ::Sequel.default_timezone = :utc
+    ::Sequel.extension(:oj_parser)
+    require 'valkyrie/sequel/metadata_adapter'
+  end
+end

data/valkyrie-sequel.gemspec

@@ -0,0 +1,36 @@
+
+# frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "valkyrie/sequel/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "valkyrie-sequel"
+  spec.version       = Valkyrie::Sequel::VERSION
+  spec.authors       = ["Trey Pendragon"]
+  spec.email         = ["tpendragon@princeton.edu"]
+
+  spec.summary       = 'Valkyrie::MetadataAdapter for Postgres using Sequel.'
+  spec.description   = 'Valkyrie::MetadataAdapter for Postgres using Sequel.'
+  spec.homepage      = "https://github.com/samvera-labs/valkyrie-sequel"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sequel"
+  spec.add_dependency "sequel_pg"
+  spec.add_dependency "valkyrie", "~> 1.5.0.RC1"
+  spec.add_dependency "oj"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "bixby"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,234 @@
+--- !ruby/object:Gem::Specification
+name: valkyrie-sequel
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Trey Pendragon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel_pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: valkyrie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0.RC1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0.RC1
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bixby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Valkyrie::MetadataAdapter for Postgres using Sequel.
+email:
+- tpendragon@princeton.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- db/migrations/.gitkeep
+- db/migrations/001_create_orm_resources.rb
+- lib/sequel/extensions/oj_parser.rb
+- lib/valkyrie/sequel.rb
+- lib/valkyrie/sequel/metadata_adapter.rb
+- lib/valkyrie/sequel/persister.rb
+- lib/valkyrie/sequel/query_service.rb
+- lib/valkyrie/sequel/resource_factory.rb
+- lib/valkyrie/sequel/resource_factory/orm_converter.rb
+- lib/valkyrie/sequel/resource_factory/resource_converter.rb
+- lib/valkyrie/sequel/version.rb
+- valkyrie-sequel.gemspec
+homepage: https://github.com/samvera-labs/valkyrie-sequel
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Valkyrie::MetadataAdapter for Postgres using Sequel.
+test_files: []