active_tree 0.2.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bf00b350061ffb40ff9a7db9cb0f10d06bea1a20eb82062ac66029d5fd1ad52
+  data.tar.gz: 6babe94e0d5f928b9bb3c14306850211c6ba4cd5660ee5cfebd6ace953e8be6a
+SHA512:
+  metadata.gz: 40dce12132b74bc1b53bb52bc1281e76c953fe8a486613ff362f742b4a51e6847b05938bfd84ea9be56230edec6112543263ef3d52caab25837c3a9ed0d2c837
+  data.tar.gz: 9679c3a799b5472be0786085c060fa1bbfa6fa8ca160412797e1a5a79fe69b2db6137573ecf4095341d98948301077e285ef27c3f0e861f462a1c55b64356f05

data/.rspec

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

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+
+gem "activerecord", "~> 6.0"
+
+gem "jwt"
+gem "pg_ltree"

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    active_tree (0.2.9)
+      activerecord (~> 6.0)
+      jwt (~> 2.2.3)
+      pg_ltree (~> 1.1.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    jwt (2.2.3)
+    minitest (5.14.4)
+    pg (1.2.3)
+    pg_ltree (1.1.8)
+      activerecord (>= 4.0.0, <= 7.0.0.rc1)
+      pg (>= 0.17.0, < 2)
+    rake (13.0.6)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  active_tree!
+  activerecord (~> 6.0)
+  jwt
+  pg_ltree
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.2.27

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 CheckThisOut
+
+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,112 @@
+[![Tests](https://github.com/nicksterious/active_tree/actions/workflows/ci.yml/badge.svg)](https://github.com/nicksterious/active_tree/actions/workflows/ci.yml) [![Ruby Gem](https://github.com/nicksterious/active_tree/actions/workflows/rubygems.yml/badge.svg)](https://github.com/nicksterious/active_tree/actions/workflows/rubygems.yml) [![Gem Version](https://badge.fury.io/rb/active_tree.svg)](https://badge.fury.io/rb/active_tree) 
+
+# ActiveTree
+
+Storing, processing and working with hierarchical data has always been challenging. A multitude of data models and implementations exist already but every one of them makes huge compromises or lacks functionality. 
+
+This gem implements a denormalized database model for tree data as well as several vectors for convenient querying. 
+
+## Installation
+
+This gem is at home within a Rails 6+ console-only, API or full fledged application on top of a Postgres database.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_tree'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install active_tree
+    
+Upon installing the gem you must run the install process in your Rails application's root:
+
+    $ rails g active_tree:install
+    
+This will generate a `config/active_tree.yml` which you may customize to your needs, an initializer and a migration file which you can also customize to add any database columns your models will require.
+
+## Usage
+
+Include the ActiveTreeAble concern into one of your models which will own lifecycle trees (owner model):
+
+```ruby
+    class User < ApplicationRecord
+        include ActiveTree::ActiveTreeAble
+        # ...
+    end
+```
+
+This will extend your model and enable the following functionality:
+
+```ruby
+# query with ActiveRecord syntax
+User.last.active_trees
+User.find_by(name: "Acme").active_trees.select("product_name, sum(product_price) as total_price").group(:product_name)
+User.last.active_trees.where(...)
+User.last.active_trees.where(...).group(...)
+User.last.active_trees.where(...).limit(...).offset(...)
+    
+# AR query with ltree syntax
+User.last.active_trees.disabled.match_path("*.ProductName.*")
+User.last.active_trees.match_path("*{5,10}.CategoryName.*.ProductName.*")
+User.last.active_trees.active.match_path("*.CategoryName.*.SubcategoryName.*.ProductName.*").where( product_price: [100..150]).sum(:product_price)
+
+ActiveTree::Model.match_path("Top.Category.*").products.match_path("*.Scooter*").where( product_price: [ 1000..10000 ]).average(:product_price)
+ActiveTree::Model.where(name: "RC Airplane").products.match_path("*.Battery.*").sum(:product_price)
+ActiveTree::Model.where(owner: User.last).match_path("*{10,20}.*Category.*")
+ActiveTree::Model.match_path("*.Product.*")
+        
+# pg_ltree queries
+User.last.active_trees.last.parent
+ActiveTree::Model.match_path("*.Category.*").children
+    
+# pg_ltree combined with AR syntax
+User.last.active_trees(type: "Sellable::Product").children.match_path("*.Battery").children
+    
+# all queries can be directed to a specific partition:
+ActiveTree::Model.owned_by( owner_id ).match_path("*.Category.*").where(currency: "USD").products.sum(:product_price)
+    
+```
+
+To see what syntax to use for path traversal please check out the following resources:
+* pg_ltree gem https://github.com/sjke/pg_ltree
+* Postgres ltree extension documentation https://www.postgresql.org/docs/9.1/ltree.html
+
+The ActiveTree gem is designed to be compatible with PostgREST. PostgREST is an amazing tool that generates a CRUD REST API for your Postgres database, read more about it here: https://postgrest.org
+
+If the `create_postgrest_roles` setting is on each new owner will be assigned a Postgres role allowing them to access data within their partition using PostgREST. Your owner model will be extended with a `.generate_jwt` method you can use to generate the PostgREST authentication token.
+
+## Metadata
+
+The `ActiveTree::Model` comes with a JSONB column where you can store random information structured in any required way. Subclasses of the Model can implement methods to store/retrieve JSONB data as well as validations.
+
+The `ActiveTree::Metadata` model can store key-value pairs queryable through ActiveRecord simple queries or joins:
+
+```ruby
+ActiveTree::Model.match_path("*.Battery.*").metadata.where(key: "Shipping weight").sum(:value)
+```
+
+## Caveats
+
+`pg_ltree` .child / .parent queries do not work across different models due to an ActiveRecord limitation that requires results to be related via inheritance. 
+
+## Roadmap
+
+* postgres RECURSIVE queries
+* builders
+* seeds/fixtures
+
+
+## Contributing
+
+Bug reports, pull requests and feature suggestions are welcome on GitHub at https://github.com/nicksterious/active_tree
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lca"
+
+# 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/lib/active_tree/active_record.rb

@@ -0,0 +1,6 @@
+# we include the concern manually so there should be no need for this anymore
+# besides, no need to polute other classes with our stuff.
+
+# ActiveSupport.on_load(:active_record) do
+#     extend ActiveTree::Lcable
+# end

data/lib/active_tree/builders/builder.rb

@@ -0,0 +1,3 @@
+class ActiveTree::Builder
+
+end

data/lib/active_tree/models/concerns/active_tree_able.rb

@@ -0,0 +1,80 @@
+require "jwt"
+
+# read https://www.postgresqltutorial.com/postgresql-schema/
+
+module ActiveTree
+    module ActiveTreeAble
+    	extend ActiveSupport::Concern
+
+        included do
+
+    	    has_many :active_trees, class_name: "::ActiveTree::Model", foreign_key: :owner_id, as: :owner
+    	    after_create :active_tree_create_storage
+    	    before_destroy :active_tree_delete_storage
+
+            # instance methods
+        	def active_tree_role
+        	    "active_tree_owner_#{id}_#{ ACTIVE_TREE_OPTIONS[:owner_role_suffix] }"
+        	end # role
+
+            # Generates a JWT token the client (SPA) can pass to PostgREST for privilege escalation
+        	def generate_jwt
+        	    payload = { role: self.active_tree_role }
+        	    ::JWT.encode payload, ACTIVE_TREE_OPTIONS[:jwt_secret], ACTIVE_TREE_OPTIONS[:jwt_encryption]
+        	end # .generate_jwt
+
+
+            # Returns the LCA table name as configured within config/active_tree.yml
+        	def active_tree_table_name
+        	    ACTIVE_TREE_OPTIONS[:table_name]
+        	end # .active_tree_table_name
+
+
+            # Creates LCA table partition and role for owner
+        	def active_tree_create_storage
+
+        	    # create data partition
+        	    active_tree_sql "create table if not exists #{active_tree_table_name}_#{id} partition of #{active_tree_table_name} for values in (#{id})"
+        	    # TODO create partition indexes
+
+            	    if ACTIVE_TREE_OPTIONS[:create_postgrest_roles]
+            		# drop role if it exists
+                	active_tree_sql "drop role if exists #{ active_tree_role }"
+
+                	# create role
+            		active_tree_sql "create role #{ active_tree_role }"
+
+        		# grant privs
+        		active_tree_sql "grant all privileges on #{active_tree_table_name}_#{id} to #{ active_tree_role }"
+            	    end
+
+        	end # create_storage
+
+
+            # Deletes or detaches the partition and removes the role for this owner
+        	def active_tree_delete_storage
+
+            	    if ACTIVE_TREE_OPTIONS[:create_postgrest_roles]
+        	        # revoke privs
+        	        active_tree_sql "REVOKE ALL PRIVILEGES ON #{active_tree_table_name}_#{id} FROM #{ active_tree_role }"
+
+        	        # delete role
+        	        active_tree_sql "drop role #{ active_tree_role }"
+            	    end
+
+            	    if ACTIVE_TREE_OPTIONS[:destroy_partition_on_owner_destroy]
+        	        # delete partition
+        	        active_tree_sql "drop table if exists #{active_tree_table_name}_#{id}"
+            	    else
+                	# detach and forget about it
+                	active_tree_sql "alter table #{active_tree_table_name} detach partition #{ active_tree_role }"
+            	    end
+        	end # delete_storage
+
+            def active_tree_sql sql
+                ActiveRecord::Base.connection.execute sql
+            end # active_tree_sql
+
+    	end # ClassMethods
+    end
+end

data/lib/active_tree/models/concerns/statusable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module ActiveTree::Statusable
+
+    extend ActiveSupport::Concern
+
+    included do
+        scope :active, -> { where(status: 1) }
+        scope :inactive, -> { where(status: 0) }
+	alias_method :enabled?, :active?
+	alias_method :enable!, :active!
+	alias_method :on!, :active!
+	alias_method :disabled?, :inactive?
+	alias_method :disable!, :inactive!
+	alias_method :off!, :inactive!
+	alias_method :toggle?, :toggle_status!
+	
+	before_create :set_default_status
+    end
+
+    def set_default_status
+	self.status ||= 1
+    end
+
+    def toggle_status!
+        if active?
+            inactive!
+        else
+            active!
+        end
+    end
+
+    def status?
+	    [:inactive, :active][ status ]
+    end
+
+    def active?
+        status == 1
+    end
+    def inactive?
+        status == 0
+    end
+
+    def active!
+        self.update(status: 1)
+    end
+    def inactive!
+        self.update(status: 0)
+    end
+end

data/lib/active_tree/models/metadata.rb

@@ -0,0 +1,12 @@
+class ActiveTree::Metadata < ActiveRecord::Base
+
+    belongs_to :model, polymorphic: true, required: true
+
+    def self.table_name
+	return "#{ ::ACTIVE_TREE_OPTIONS[:table_name] }_metadata" if defined? ::LCA_OPTIONS
+	return "active_tree_models_metadata"
+    end
+    
+    validates_presence_of :key
+
+end

data/lib/active_tree/models/model.rb

@@ -0,0 +1,75 @@
+class ActiveTree::Model < ActiveRecord::Base
+
+    include ActiveTree::Statusable
+
+    self.primary_key = :id
+
+    ltree :path
+
+    def self.table_name
+        return ::ACTIVE_TREE_OPTIONS[:table_name] if defined? ::ACTIVE_TREE_OPTIONS
+        return "active_tree_models"
+    end
+
+    belongs_to :owner, polymorphic: :true, required: true
+
+    scope :match_path, -> (some_path) { where("path ~ ?", "#{some_path}") }
+
+    validates_presence_of :name, allow_blank: false
+    validates_presence_of :path, allow_blank: false
+
+    has_many :metadata, class_name: "::ActiveTree::Metadata", dependent: :destroy, as: :model
+
+    before_validation :set_defaults
+    def set_defaults
+        self.path ||= name.delete(" ").gsub(/[^0-9a-z ]/i, '') if name
+        self.path_slug = path.parameterize if path
+        self.metadata_inline ||= {}
+    end
+
+
+    # Scoping by owner in order to select the partition
+    #
+    # @param owner_id [Integer] the partition owner
+    def self.owned_by(owner_id)
+        # if we're looking for anything else but an integer, revert to the base class
+        return self if !owner_id.is_a? Integer
+
+        partition_suffix = "_#{owner_id}"
+
+        table = "#{ self.table_name }#{ partition_suffix }"
+
+        ApplicationRecord.connection.schema_cache.clear!
+        return self if !ApplicationRecord.connection.schema_cache.data_source_exists? table
+
+        # duplicate the class
+        model_class = Class.new self
+        original_class_name = self.name
+
+        # ...for this owner
+        class_name = "#{name}#{partition_suffix}"
+
+        # specify the table
+        model_class.define_singleton_method(:table_name) do
+            table
+        end
+
+        # specify the name
+        model_class.define_singleton_method(:name) do
+            class_name
+        end
+
+	model_class.define_singleton_method(:sti_name) do
+	    original_class_name
+	end
+
+        # override the STI name lmfao
+        model_class.define_singleton_method(:find_sti_class) do |p|
+            original_class_name.constantize
+        end
+
+        # proceed
+        model_class
+    end # .owned_by
+
+end

data/lib/active_tree/queries/active_tree_query.rb

@@ -0,0 +1,9 @@
+class ActiveTree::Query
+    def valid?(attribute, value)
+        return false if !attribute.is_a? Symbol
+        return false if value.nil? || value.empty? || !value.present?
+        return valse if [ "", [], ["0"], [ 0 ], "all", "any" ].include? value
+        return true
+    end # valid?
+
+end

data/lib/active_tree/queries/model_query.rb

@@ -0,0 +1,31 @@
+class ActiveTree::ModelQuery < ActiveTree::Query
+    attr_accessor :initial_scope
+
+    def initialize(initial_scope = ::ActiveTree::Model.all)
+	@initial_scope = initial_scope
+    end # initialize
+
+    def call(params)
+	scope = simple_search(initial_scope, :id, params[:id])
+	[:owner_type, :owner_id, :status, :data_external_id, :data_provider, :type, :parent_entity_id, :parent_entity_type, :path_slug].each do |query|
+	    scope = simple_search(scope, query, params[query])
+	end
+
+	scope = by_search(scope, params[:search])
+
+	scope
+    end # call
+
+
+    # Partial search by name
+    def by_search(scope, search = nil)
+	search ? scope.where("lower(name) like ?", "%#{search.downcase}%") : scope
+    end # by_search
+
+
+    # Simple search by attribute and exact value
+    def simple_search(scope, attribute = nil, value = nil)
+	valid?(attribute, value) ? scope.where(attribute => value) : scope
+    end # simple search
+
+end

data/lib/active_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveTree
+  VERSION = "0.2.9"
+end

data/lib/active_tree.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require "active_support/all"
+
+require "active_record"
+
+require "pg_ltree"
+
+require_relative "active_tree/version"
+
+require_relative "active_tree/models/concerns/statusable"
+require_relative "active_tree/models/metadata"
+require_relative "active_tree/models/model"
+
+require_relative "active_tree/models/concerns/active_tree_able"
+require_relative "active_tree/active_record"
+
+# TODO add query objects and builders
+require_relative "active_tree/queries/active_tree_query"
+require_relative "active_tree/queries/model_query"
+#require_relative "active_tree/builders/"
+
+module ActiveTree
+    class Error < StandardError; end
+
+    # Your code goes here...
+
+    class << self
+    	attr_accessor :active_tree_models
+    	attr_accessor :options
+    end
+
+    self.active_tree_models = []
+
+    def self.active_tree_options
+	    @options ||= begin
+    	    path = Rails.root.join("config", "active_tree.yml").to_s
+    	    if File.exist?(path)
+    		    YAML.load(ERB.new(File.read(path)).result)
+    	    else
+        		{
+        		    table_name: "active_tree_models",
+        		    jwt_secret: "",
+        		    jwt_encryption: "HS256"
+        		}
+    	    end
+    	end
+    end
+
+    def self.env
+        @env ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
+end

data/lib/generators/active_tree/install_generator.rb

@@ -0,0 +1,29 @@
+require "rails/generators/active_record"
+
+module ActiveTree
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.join(__dir__, "templates")
+
+      def copy_migration
+        migration_template "migration.rb.tt", "db/migrate/install_active_tree.rb", migration_version: migration_version
+      end
+
+      def copy_initializer
+	    copy_file 'initializer.rb.tt', 'config/initializers/active_tree.rb'
+      end
+
+      def copy_config
+        conf_file = "config/active_tree.yml"
+        copy_file "config.yml.tt", conf_file
+        contents = File.read( conf_file ).gsub("changeme", ('a'..'z').to_a.shuffle.first(4).join )
+        File.open(conf_file, 'wb') { |file| file.write(contents) }
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/active_tree/templates/config.yml.tt

@@ -0,0 +1,18 @@
+# the main table will be called "active_tree_models"
+# partitions will be called "active_tree_models_X" where X is the owner object ID
+table_name: "active_tree_models"
+
+# create PG roles for postgrest: anon and owner-specific roles
+create_postgrest_roles: true
+
+# on owner removal, detach the partition but preserve the table and data, or destroy the partition and data
+# if you choose to detach and preserve, in order to avoid table name collisions, make sure owner IDs are not reused
+destroy_partition_on_owner_destroy: true
+
+# jwt secret required for postgrest role switching
+jwt_secret: "supersecret"
+jwt_encryption: "HS256"
+
+# suffix postgres roles with a random string 
+# to avoid collisions between other LCA installations in other apps using same db server
+owner_role_suffix: "changeme"

data/lib/generators/active_tree/templates/initializer.rb.tt

@@ -0,0 +1,17 @@
+ACTIVE_TREE_OPTIONS ||= begin
+    path = Rails.root.join("config", "active_tree.yml").to_s
+    if File.exist?(path)
+        YAML.load( ERB.new(File.read(path)).result ).deep_symbolize_keys
+    else
+        {
+            table_name: "active_tree_models",
+            create_postgrest_roles: true,
+            jwt_secret: "supersecret",
+            jwt_encryption: "HS256",
+            destroy_partition_on_owner_destroy: true,
+            owner_role_suffix: "changeme"
+        }
+    end
+end.merge({
+    database_user: Rails.application.config.database_configuration[ Rails.env ].deep_symbolize_keys[:username]
+})

data/lib/generators/active_tree/templates/migration.rb.tt

@@ -0,0 +1,82 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+
+    # enable ltree extension
+    begin
+	execute "create extension ltree"
+    rescue
+	p "LTREE was already enabled"
+    end
+    
+
+    # create the main table as set up within ACTIVE_TREE_OPTIONS[:table_name]
+    execute <<-SQL
+    create table #{ ACTIVE_TREE_OPTIONS[:table_name] } (
+	id serial,
+
+	owner_id integer,
+	owner_type character varying,
+	
+	status integer,
+
+	data_external_id character varying,
+	data_provider character varying,
+
+	type character varying,
+	name text,
+
+	parent_entity_id integer,
+	parent_entity_type character varying,
+
+	path ltree,
+    	path_slug text,
+    	
+    	metadata_inline jsonb,
+
+	created_at timestamp(6) without time zone not null,
+	updated_at timestamp(6) without time zone not null,
+
+	primary key (id, owner_id)
+    ) partition by list(owner_id)
+SQL
+
+    # create an "others" partition for when the owner is undefined/unknown? just in case / may help in some edge cases
+    execute "CREATE TABLE #{ACTIVE_TREE_OPTIONS[:table_name]}_others PARTITION OF #{ACTIVE_TREE_OPTIONS[:table_name]} DEFAULT"
+
+
+    # add indexes
+    add_index ACTIVE_TREE_OPTIONS[:table_name], :id
+    add_index ACTIVE_TREE_OPTIONS[:table_name], :owner_id
+    add_index ACTIVE_TREE_OPTIONS[:table_name], :type
+    add_index ACTIVE_TREE_OPTIONS[:table_name], :parent_entity_id
+
+    # next two indexes unfortunately can't be unique since a cycle can appear several times under an owner
+    add_index ACTIVE_TREE_OPTIONS[:table_name], :path, using: :gist
+    add_index ACTIVE_TREE_OPTIONS[:table_name], [:data_provider, :data_external_id]
+
+
+    # when postgrest is enabled...
+    if ACTIVE_TREE_OPTIONS[:create_postgrest_roles]
+    	# create postgrest anon user with no privs
+    	# postgrest may pass an user's role using JWT
+    	execute "drop role if exists postgrest_anon"
+    	execute "create role postgrest_anon nologin"
+    	execute "grant postgrest_anon to #{ ACTIVE_TREE_OPTIONS[:database_user] }"
+    end
+
+
+
+
+    # metadata table
+    create_table "#{ ACTIVE_TREE_OPTIONS[:table_name] }_metadata" do |t|
+	t.string :model_type
+	t.integer :model_id
+	t.string :key
+	t.text :value
+	
+	t.timestamps
+    end
+    add_index "#{ ACTIVE_TREE_OPTIONS[:table_name] }_metadata", [ :model_type, :model_id ]
+    add_index "#{ ACTIVE_TREE_OPTIONS[:table_name] }_metadata", [ :key ]
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: active_tree
+version: !ruby/object:Gem::Version
+  version: 0.2.9
+platform: ruby
+authors:
+- Nick @ Earthster
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: pg_ltree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+description: This gem allows storing and querying tree data in a meaningful, comprehensive
+  way using a Postgres ltree structure
+email:
+- nick@earthster.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/active_tree.rb
+- lib/active_tree/active_record.rb
+- lib/active_tree/builders/builder.rb
+- lib/active_tree/models/concerns/active_tree_able.rb
+- lib/active_tree/models/concerns/statusable.rb
+- lib/active_tree/models/metadata.rb
+- lib/active_tree/models/model.rb
+- lib/active_tree/queries/active_tree_query.rb
+- lib/active_tree/queries/model_query.rb
+- lib/active_tree/version.rb
+- lib/generators/active_tree/install_generator.rb
+- lib/generators/active_tree/templates/config.yml.tt
+- lib/generators/active_tree/templates/initializer.rb.tt
+- lib/generators/active_tree/templates/migration.rb.tt
+homepage: https://github.com/nicksterious/active_tree
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nicksterious/active_tree
+  source_code_uri: https://github.com/nicksterious/active_tree
+  changelog_uri: https://github.com/nicksterious/active_tree/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: A partitioned storage backend for tree data
+test_files: []