actn-db 0.0.1

data/lib/actn/core_ext/string.rb

@@ -0,0 +1,14 @@
+require 'oj'
+
+class ::String
+  def to_json
+    self
+  end
+  def as_json
+    Oj.load(self)
+  end
+  def to_domain
+    return self unless self.start_with?("http")
+    self.match(/[http|http]:\/\/(\w*:\d*|\w*)\/?/)[1] rescue nil
+  end
+end

data/lib/actn/db.rb

@@ -0,0 +1,24 @@
+require "actn/paths"
+require "actn/db/version"
+require "actn/db/pg"
+require "actn/db/set"
+require "actn/db/mod"
+require "actn/db/model"
+
+module Actn
+  
+  module DB
+    extend PG
+    include Paths
+    
+    def self.gem_root
+      @@gem_root ||= File.expand_path('../../../', __FILE__)
+    end
+    
+    def self.paths
+      @@paths ||= [self.gem_root]
+    end
+    
+  end
+  
+end

data/lib/actn/db/mod.rb

@@ -0,0 +1,175 @@
+require 'actn/db/pg'
+require 'actn/db/set'
+require "active_model"
+
+module Actn
+  module DB
+    class Mod
+      
+      include PG
+      
+      include ActiveModel::Model
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+      include ActiveModel::Serializers::JSON
+
+      define_model_callbacks :create
+      define_model_callbacks :update
+      define_model_callbacks :destroy
+      
+      class << self
+    
+        attr_accessor :schema, :table, :set
+        
+        def set
+          @set ||= Set.new(schema, table)
+        end
+        
+        def data_attr_accessor *fields
+          fields.each do |field|
+            class_eval %Q{ 
+              def #{field}; self.attributes['#{field}'] end
+              def #{field}=val; self.attributes['#{field}']=val end
+            }
+          end 
+        end
+        
+        def create data = {}
+          record = new(data)
+          record.save
+          record
+        end
+        
+        [:validate_and_upsert, :upsert, :update, :delete, :delete_all].each do |meth|
+          class_eval <<-RUBY
+          def #{meth} *args
+            set.#{meth}(*args)
+          end
+          RUBY
+        end
+        
+        [:find_by, :find].each do |meth|
+          class_eval <<-RUBY
+          def #{meth} conds
+            return nil if conds.empty?
+            new.from_json(set.#{meth}(conds)) rescue nil
+          end
+          RUBY
+        end
+        
+        [:all, :where].each do |meth|
+          class_eval <<-RUBY
+          def #{meth} *args
+            (Oj.load(set.#{meth}(*args)) rescue {}).map{ |attrs| new(attrs) }
+          end
+          RUBY
+        end
+        
+        def count conds = {}
+          set.count(conds).match(/(\d+)/)[1].to_i
+        end
+      
+      end
+      
+      self.schema = "public"
+      
+      attr_accessor :attributes
+      data_attr_accessor :uuid, :locale, :created_at, :updated_at
+      
+      
+      def initialize data = {}
+        data ||= {}
+        register_attr_accessors data
+        super(data)
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def persisted?
+        self.uuid.present?
+      end
+
+      def uuid
+        self.attributes['uuid']
+      end
+
+      ##
+      # persistency
+
+      def save
+        create_or_update if valid?
+      end
+
+      def update attrs
+        register_attr_accessors attrs        
+        self.attributes.update(attrs)
+        save
+      end
+
+      def destroy
+        return unless self.persisted?
+        run_callbacks :destroy do
+          if result = self.class.delete(identity)
+            process_upsert_response result
+          end
+        end
+      end
+
+
+      private
+
+      def create_or_update
+        self.persisted? ? _update : _insert
+      end
+
+      def _update
+        run_callbacks :update do        
+          # if result = self.class.update(self.attributes,identity)
+          if result = self.class.validate_and_upsert(self.attributes.merge(identity))          
+            process_upsert_response result
+          end
+        end
+      end
+
+      def _insert
+        run_callbacks :create do
+          if result = self.class.validate_and_upsert(self.attributes)
+            process_upsert_response result
+          end
+        end
+      end
+
+      def identity
+        {'uuid' => self.uuid}
+      end
+    
+      ##
+      # allows dynamic attributes! 
+    
+      def register_attr_accessors data
+        data.deep_stringify_keys!
+        # ignore attributes declared with attr_accessor method
+        self.class.data_attr_accessor *data.keys.keep_if{ |key| 
+          public_methods.keep_if{ |n| n.to_s.start_with? key }.empty? 
+        }
+      end
+      
+      private
+      
+      def process_upsert_response result
+        if result =~ /uuid/
+          self.from_json(result)            
+        elsif result =~ /error/
+          JsonSchemaError.new(result).errors.each do |field,err|
+            errors.add(field,err.keys.flatten.join(","))            
+          end
+        end
+        self
+      end
+    
+    end
+  end
+end

data/lib/actn/db/model.rb

@@ -0,0 +1,25 @@
+require 'actn/db/mod'
+require 'active_support/inflector'
+
+module Actn
+  module DB
+    class Model < Mod
+        
+      self.table = "models"
+      self.schema = "core" 
+      
+      data_attr_accessor :table_schema, :name, :indexes, :schema, :hooks
+      
+      before_create :classify_name
+      before_update :classify_name      
+      
+      private
+      
+      def classify_name
+        self.name = self.name.classify if self.name
+      end
+      
+     
+    end
+  end
+end

data/lib/actn/db/pg.rb

@@ -0,0 +1,88 @@
+require 'oj'
+require 'uri'
+require 'pg/em'
+require 'pg/em/connection_pool'
+require 'active_support/inflector'
+require 'actn/core_ext/hash'
+require 'actn/core_ext/string'
+
+module Actn
+  module DB
+    module PG
+      
+      class JsonSchemaError < StandardError
+        def initialize payload
+          # puts " PAYLOAD #{payload}"
+          @errors = Oj.load(payload)['errors']['validation']
+        end
+        def errors  
+          @errors
+        end
+      end
+      
+      Oj.default_options = { time_format: :ruby, mode: :compat }
+    
+      def exec_func func_name, *params
+        sql = "SELECT __#{func_name}(#{ (params.length-1).times.inject("$1"){ |m,i| "#{m},$#{ i + 2 }"} })"
+        exec_prepared sql.parameterize.underscore, sql, params
+      end
+    
+      def exec_prepared statement, sql, params = []
+        
+        pg.prepare statement, sql rescue ::PG::DuplicatePstatement
+        
+        begin          
+          result = pg.exec_prepared(statement, params)
+          json = result.values.flatten.first
+          result.clear
+          json
+        rescue ::PG::InvalidSqlStatementName
+          exec_params sql, params
+        end
+        
+      end
+    
+      def exec_params sql, params = []
+        result = pg.exec_params(sql, params)
+        json = result.values.flatten.first
+        result.clear
+        json
+      end
+    
+      ##
+      # :singleton method
+      # holds db connection
+
+      def pg 
+        @@connection_pool ||= ::PG::EM::ConnectionPool.new(db_config)
+      end
+      
+      
+      ##
+      # :singleton method
+      # parses database url
+      
+      def db_config
+        @@config ||= begin
+          db = URI.parse(ENV['DATABASE_URL'] || 'postgres://localhost')
+          config = {
+            dbname: db.path[1..-1],
+            host: db.host,
+            port: db.port,
+            size: ENV['DB_POOL_SIZE'] || 5,          
+            async_autoreconnect: ENV['DB_ASYNC_AUTO_RECONNECT'] || true,
+            connect_timeout: ENV['DB_CONN_TIMEOUT'] || 60,
+            query_timeout: ENV['DB_QUERY_TIMEOUT'] || 30,
+            on_autoreconnect: proc { |pg| pg.exec "SELECT plv8_startup();" rescue nil },
+            on_connect: proc { |pg| pg.exec "SELECT plv8_startup();" rescue nil }
+          }
+          config[:user] = db.user if db.user
+          config[:password] = db.password if db.password
+          config
+        end
+      end
+    
+    end
+  
+  end
+end

data/lib/actn/db/set.rb

@@ -0,0 +1,67 @@
+require 'actn/db/pg'
+
+module Actn
+  module DB
+    class Set
+      
+      include PG
+      
+      def self.tables
+        @@tables ||= {}
+      end
+      
+      def self.[]table
+        self.tables[table] ||= new(table)
+      end
+      
+      attr_accessor :table, :schema
+      
+      def initialize schema = :public, table
+        self.table = table
+        self.schema = schema
+      end
+
+      
+      [:query,:upsert, :update, :delete].each do |meth|
+        class_eval <<-CODE
+        def #{meth} *args
+          exec_func :#{meth}, schema, table, *args.map(&:to_json)
+        end
+        CODE
+      end
+      
+      def validate_and_upsert data
+        sql = "SELECT __upsert($1,$2,__validate($3,$4))"
+        exec_prepared sql.parameterize.underscore, sql, [schema, table, table.classify, data.to_json]
+      end
+
+      
+      def count conds = {}
+        exec_func :query, schema, table, {select: 'COUNT(id)'}.merge(conds).to_json
+      end
+      
+      
+      def all
+        where({})
+      end
+      
+      def where cond
+        query({where: cond})        
+      end
+      
+      def find_by cond
+        query({where: cond,limit: 1})[1..-2]
+      end
+      
+      def find uuid
+        find_by(uuid: uuid)
+      end
+      
+      def delete_all
+        delete({})
+      end
+      
+    
+    end
+  end
+end

data/lib/actn/db/tasks/db.rake

@@ -0,0 +1,96 @@
+require 'actn/db'
+
+namespace :db do
+
+  desc "erases and rewinds all dbs"
+  task :reset do
+    Rake::Task["db:drop"].execute 
+    Rake::Task["db:create"].execute 
+    Rake::Task["db:migrate"].execute 
+  end
+  
+  desc "migrate your database"
+  task :migrate do
+    
+    puts "Db Migrating... #{db_config[:dbname]}"        
+    pg = PG::EM::Client.new(db_config)
+    
+
+          
+    Actn::DB.paths.uniq.each do |path|
+      
+      puts path
+
+      pg.exec(File.read("#{path}/db/__setup.sql")) if File.exists?("#{path}/db/__setup.sql")
+
+      if File.exists?("#{path}/db/lib")
+       `coffee --compile --output #{path}/db/lib #{path}/db/lib` rescue nil        
+       
+        Dir.glob("#{path}/db/lib/*.js").each do |js|
+          name = File.basename(js,".js").split("_").last
+          sql = "INSERT INTO plv8_modules values ($1,true,$2)"
+          pg.exec_params(sql,[name,File.read(js)])
+        end  
+      end
+      
+      pg.exec(File.read("#{path}/db/__functions.sql")) if File.exists?("#{path}/db/__functions.sql")      
+      
+      if File.exists?("#{path}/db/")
+        Dir.glob("#{path}/db/*.sql").each do |sql|
+          unless File.basename(sql,".sql").start_with? "__"
+            puts sql
+            pg.exec(File.read(sql)) 
+          end
+        end   
+      end
+      
+      if File.exists?("#{path}/db/schemas")
+        Dir.glob("#{path}/db/schemas/*.json").each do |json|
+          name = File.basename(json,".json").capitalize
+          schema = {schema: Oj.load(File.read(json))}
+          
+          sql = "UPDATE core.models SET data = __patch(data,$1,true) WHERE __string(data,'name'::text) = $2 RETURNING id;"
+          updated = pg.exec_params(sql,[ Oj.dump(schema), name ]).values.flatten(1).first.to_i
+          
+          if updated == 0
+            sql = "INSERT INTO core.models (data) values (__patch(__defaults(),$1,true)) RETURNING id;"
+            inserted = pg.exec_params(sql, [Oj.dump(schema.merge(name: name, table_schema: "core"))]).values.flatten(1).first.to_i
+          end
+          
+          puts "#{name} inserted:#{inserted} updated:#{updated}"  
+        end   
+        
+        pg.exec "SELECT plv8_startup();"
+        
+      end
+      
+      
+    end    
+
+  end
+
+  desc 'Drops the database'
+  task :drop  do
+    puts "Db Dropping... #{db_config[:dbname]}"        
+    pg = PG::EM::Client.new(pg_config)
+    sql = "DROP DATABASE IF EXISTS \"%s\";" % [db_config[:dbname]]
+    pg.exec(sql).error_message
+  end
+
+  desc 'Creates the database'
+  task :create do         
+    puts "Db Creating... #{db_config[:dbname]}"            
+    pg = PG::EM::Client.new(pg_config)
+    sql = "CREATE DATABASE \"%s\" ENCODING = 'utf8';" % [db_config[:dbname]]
+    pg.exec(sql)
+  end
+  
+  def db_config
+    @db_config ||= Actn::DB.db_config.dup.tap{|s| s.delete(:size) }
+  end
+  
+  def pg_config
+    @pg_config ||= db_config.dup.merge({'dbname' => 'postgres'})
+  end
+
+end