actn-db 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ca2965b4c761b78728413b0c7a0fef06bbb1432
-  data.tar.gz: 04739049558b259764222239754d5f35230ae0d1
+  metadata.gz: dd259d933b75cb3242fb249565474fc0148dd845
+  data.tar.gz: d62618f10c7f70e88666f1b3a92d3b11c7a8441f
 SHA512:
-  metadata.gz: 01e20e754b6e96bcd1e796cab2dd167073d735ec8c44b1fe1b802fbd712720cc4a83e3f262a79cb42589d5c5c0d015de6a708a2d2f8d02989358745cb83106a1
-  data.tar.gz: 570c971b36b4337645a7ff0bac4fb074848b1a065341bc4fcbabaeff20353edcc0f962af30c806f73a96273484cfd8b0178a6e147ad6a9ddd32e44b3b7eeb41f
+  metadata.gz: 87e5f43fb7a3e59e4c5f38fd0f58f8de1e19444602d1f5d09d3a7608577f95d944884d01a38811654da271bc0a4e8a8f275b666411a393a55124134a4596f7b1
+  data.tar.gz: 4b40c257fa8b7a2ed85401f8013742fe99ff16f462098bebd2eb8ab55d14dabc975d07ce783815ec8109d4232d3053a10e5f0e336550a223059d6f5deede406e

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in actn-db.gemspec
-gemspec
+gemspec

data/Rakefile

@@ -9,4 +9,4 @@ end
 task :default => :test
 
 ENV['DATABASE_URL'] ||= "postgres://localhost:5432/actn_#{ENV['RACK_ENV'] ||= "development"}" 
-load "actn/db/tasks/db.rake"
+load "actn/db/tasks/db.rake"

data/db/1_db.sql

@@ -7,10 +7,8 @@ SELECT __create_table('core','models');
 SELECT __create_index('core','models', '{"cols": {"name": "text"},"unique": true}');
 
 
-CREATE or REPLACE FUNCTION model_callbacks() RETURNS trigger AS
-$$
+CREATE or REPLACE FUNCTION model_callbacks() RETURNS trigger AS $$
   actn.funcs.model_callbacks(TG_OP, NEW, OLD);
-    
 $$ LANGUAGE plv8 STABLE STRICT;
 
 CREATE TRIGGER core_models_callback_trigger 

data/db/__functions.sql

@@ -6,232 +6,150 @@ $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __string(_data json, _key text) RETURNS TEXT AS $$
   return actn.funcs.__string(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __integer(_data json, _key text) RETURNS INT AS $$
   return actn.funcs.__integer(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __integer_array(_data json, _key text) RETURNS INT[] AS $$
   return actn.funcs.__integer_array(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __float(_data json, _key text) RETURNS DOUBLE PRECISION AS $$
   return actn.funcs.__float(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __bool(_data json, _key text) RETURNS BOOLEAN AS $$
   return actn.funcs.__bool(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __timestamp(_data json, _key text) RETURNS TIMESTAMP AS $$
   return actn.funcs.__timestamp(_data, _key);
-
 $$ LANGUAGE plv8 IMMUTABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __patch(_data json, _value json, _sync boolean) RETURNS JSON AS $$
   return actn.funcs.__patch(_data, _value, _sync);
-
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __select(_data json, _fields text) RETURNS JSON AS $$
-  return actn.funcs.__select(_data, _fields);
- 
+  return actn.funcs.__select(_data, _fields); 
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __push(_data json, _key text, _value json) RETURNS JSON AS $$
   return actn.funcs.__push(_data, _key, _value);
-  
-
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __uuid() RETURNS JSON AS $$
-  return actn.funcs.__uuid();
-  
-
+  return actn.funcs.__uuid();  
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
-
 CREATE or REPLACE FUNCTION __defaults() RETURNS JSON AS $$
   return actn.funcs.__defaults();
-
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __create_table(schema_name text, table_name text) RETURNS JSON AS $$
-  return actn.funcs.__create_table(schema_name, table_name);
-  
- 
+  return actn.funcs.__create_table(schema_name, table_name);  
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __drop_table(schema_name text, table_name text) RETURNS JSON AS $$
-  return actn.funcs.__drop_table(schema_name, table_name);
- 
+  return actn.funcs.__drop_table(schema_name, table_name); 
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __create_index(schema_name text, table_name text, optns json) RETURNS JSON AS $$
-
   return actn.funcs.__create_index(schema_name, table_name, optns);
- 
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 CREATE or REPLACE FUNCTION __drop_index(schema_name text, table_name text, optns json) RETURNS JSON AS $$
-  return actn.funcs.__drop_index(schema_name, table_name, optns);
-  
- 
+  return actn.funcs.__drop_index(schema_name, table_name, optns);  
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
-
 -- ##
 -- # Select data
 -- # SELECT query(_schema_name, _table_name, {where: {uuid: "12345"}});
 
 CREATE or REPLACE FUNCTION __query(_schema_name text, _table_name text, _query json) RETURNS json AS $$
   return actn.funcs.__query(_schema_name, _table_name, _query);
-  
-
 $$ LANGUAGE plv8 STABLE;
 
 
 
-
-
 -- ##
 -- # Insert ot update row through validation!
 -- # SELECT upsert(validate('User', '{"name":"foo"}'));
 
 CREATE or REPLACE FUNCTION __upsert(_schema_name text, _table_name text, _data json) RETURNS json AS $$
-  return actn.funcs.__upsert(_schema_name, _table_name, _data);
- 
+  return actn.funcs.__upsert(_schema_name, _table_name, _data); 
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 -- ##
 -- # Delete single row by uuid
 -- # SELECT remove('users',uuid-1234567);
 
 CREATE or REPLACE FUNCTION __update(_schema_name text, _table_name text, _data json, _cond json) RETURNS json AS $$
-  return actn.funcs.__update(_schema_name, _table_name, _data, _cond);  
- 
+  return actn.funcs.__update(_schema_name, _table_name, _data, _cond);   
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 -- ##
 -- # Delete single row by uuid
 -- # SELECT remove('users',uuid-1234567);
 
 CREATE or REPLACE FUNCTION __delete(_schema_name text, _table_name text, _cond json) RETURNS json AS $$
-  return actn.funcs.__delete(_schema_name, _table_name, _cond);  
-  
-   
+  return actn.funcs.__delete(_schema_name, _table_name, _cond);     
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
-
-
 -- ##
 -- # Validate data by json schema
 -- # SELECT validate(model_name, data);
 
 CREATE or REPLACE FUNCTION __validate(_name text, _data json) RETURNS json AS $$
-  return actn.funcs.__validate(_name, _data);  
-  
- 
+  return actn.funcs.__validate(_name, _data);    
 $$ LANGUAGE plv8 STABLE STRICT;
 
 
 
-
-
 -- ##
 -- # finds model with given name
 -- # SELECT __find_model(model_name);
 
 CREATE or REPLACE FUNCTION __find_model(_name text) RETURNS json AS $$
-  return actn.funcs.__find_model(_name);  
-  
- 
+  return actn.funcs.__find_model(_name);   
 $$ LANGUAGE plv8 STABLE STRICT;
-
-
-
-
-
-

data/db/__setup.sql

@@ -6,34 +6,25 @@ CREATE EXTENSION IF NOT EXISTS "plv8";
 
 
 
-
 -- Js Libs
 
 CREATE TABLE plv8_modules(modname text primary key, load_on_start boolean, code text);
 
 CREATE OR REPLACE FUNCTION plv8_startup() RETURNS void AS $$
   
-  var code, load_module, r, rows;
-
-  load_module = function(modname) {
-    var code, r, rows;
-    rows = plv8.execute("SELECT code from public.plv8_modules " + " where modname = $1", [modname]);
-    r = 0;
-    while (r < rows.length) {
-      code = rows[r].code;
-      eval("(function(){" + code + "})")();
-      r++;
-    }
-  };
+  var code, r, rows;
 
-  rows = plv8.execute("SELECT modname, code from public.plv8_modules where load_on_start");
+  code = "";
+  
+  rows = plv8.execute("SELECT modname, code from public.plv8_modules order by modname");
 
   r = 0;
 
   while (r < rows.length) {
-    code = rows[r].code;
-    eval("(function(){" + code + "})")();
+    code += rows[r].code;
     r++;
   }
+  
+  eval("(function(){" + code + "})")();  
     
 $$ LANGUAGE plv8 STABLE STRICT;

data/db/lib/_2_jjv.js

@@ -734,6 +734,5 @@
     define(function () {return Environment;});
   else
     this.jjv = Environment;
-}).call(this);
-
-global.actn.jjv = jjv();
+  
+}).call(this);

data/db/lib/_3_actn.js

@@ -0,0 +1,31 @@
+// global = (function() {
+//   return this;
+// }).call(null);
+
+(function(){
+  
+  var root = this,
+  
+  Actn = (function() {
+    function Actn() {}
+
+    Actn.prototype.valueAt = function(data, key) {
+      var i, keys;
+      keys = key.split(".");
+      for (i in keys) {
+        if (data != null) {
+          data = data[keys[i]];
+        }
+      }
+      return data;
+    };
+
+    return Actn;
+
+  })();
+
+  root.actn = new Actn();
+
+  root.actn.jjv = jjv();
+
+}).call(this);

data/db/lib/_4_functions.coffee

@@ -0,0 +1,387 @@
+(->
+  root = this
+  
+  class Funcs
+
+    __json: (_data, _key) ->
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?   
+      return JSON.stringify(ret)
+
+    __string: (_data, _key) ->
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return ret.toString()  
+
+    __integer: (_data, _key) -> 
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return parseInt(ret)  
+  
+    __integer_array: (_data, _key) -> 
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return (if ret instanceof Array then ret else [ret])
+  
+    __float: (_data, _key) -> 
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return parseFloat(ret)
+  
+    __bool: (_data, _key) ->
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return !!ret  
+  
+    __timestamp: (_data, _key) ->
+      ret = actn.valueAt(_data,_key) 
+      return null unless ret?  
+      return new Date(ret)  
+  
+    __patch: (_data, _value, _sync) ->
+
+      data = _data
+      changes = _value
+      isObject = false
+
+      sync = if _sync? then _sync else true
+
+      defaults = _.pick( data, _.keys( JSON.parse( plv8.find_function('__defaults')() ) ) )
+
+      for k of changes
+        if data.hasOwnProperty(k)
+          isObject = typeof (data[k]) is "object" and typeof (changes[k]) is "object"
+          data[k] = if isObject and sync then _.extend(data[k], changes[k]) else changes[k]
+        else
+          data[k] = changes[k]
+
+      unless sync
+        for k of data
+          delete data[k] unless changes[k]?
+
+      _.extend(data, defaults)
+
+      return JSON.stringify(data)    
+
+    __select: (_data, _fields) ->
+      data = _data
+      fields = _fields
+      ret = _.pick(data,fields.split(","))
+    
+      return JSON.stringify(ret)   
+
+    __push: (_data, _key, _value) ->
+      data = _data
+      value = _value
+      keys = _key.split(".")
+      len = keys.length
+      last_field = data
+      field = data
+      i = 0
+
+      while i < len
+        last_field = field
+        field = field[keys[i]]  if field
+        ++i
+      if field
+        field.push value
+      else
+        value = [value]  unless value instanceof Array
+        last_field[keys.pop()] = value
+  
+      return JSON.stringify(data)
+
+    __uuid: () ->
+      ary = plv8.execute 'SELECT uuid_generate_v4() as uuid;'
+      return JSON.stringify(ary[0])  
+  
+    __defaults: () ->
+      uuid = JSON.parse(plv8.find_function('__uuid')())
+      timestamp = new Date()  
+      return JSON.stringify({uuid: uuid.uuid, created_at: timestamp, updated_at: timestamp})  
+  
+    __create_table: (schema_name, table_name) ->
+      plv8.execute """
+        CREATE TABLE #{schema_name}.#{table_name} (
+        id serial NOT NULL,
+        data json DEFAULT __uuid() NOT NULL,
+        CONSTRAINT #{schema_name}_#{table_name}_pkey PRIMARY KEY (id));
+  
+        CREATE UNIQUE INDEX indx_#{schema_name}_#{table_name}_unique_uuid ON #{schema_name}.#{table_name} (__string(data,'uuid'));
+      """
+      return JSON.stringify(table_name)  
+  
+    __drop_table: (schema_name, table_name) ->  
+        plv8.execute "DROP TABLE IF EXISTS #{schema_name}.#{table_name} CASCADE;"
+        return JSON.stringify(table_name)
+    
+    __create_index: (schema_name, table_name, optns) ->
+      index_name = "indx_#{schema_name}_#{table_name}"
+      for name, type of optns.cols
+        index_name += "_#{name}"
+  
+      sql = ["CREATE"]
+      sql.push "UNIQUE" if optns.unique
+      sql.push "INDEX"
+      sql.push "CONCURRENTLY" if optns.concurrently
+      sql.push "#{index_name} on #{schema_name}.#{table_name}"  
+      sql.push "("  
+      cols = []    
+      for name, type of optns.cols
+        meth = "__#{if type is 'text' then 'string' else type}"
+        cols.push "#{meth}(data,'#{name}'::#{type})"
+      sql.push cols.join(",")
+      sql.push ")"
+  
+      sql = sql.join(" ")
+  
+      plv8.execute(sql)
+
+      return JSON.stringify(index_name)    
+  
+    __drop_index: (schema_name, table_name, optns) -> 
+      index_name = "indx_#{schema_name}_#{table_name}"
+      for name, type of optns.cols
+        index_name += "_#{name}"
+
+      plv8.execute("DROP INDEX IF EXISTS #{index_name}")
+
+      return JSON.stringify(index_name)
+  
+    __query: (_schema_name, _table_name, _query) ->
+      search_path = if _schema_name is "public" then _schema_name else "#{_schema_name}, public"
+
+      builder = new actn.Builder(_schema_name, _table_name, search_path, _query)
+
+      [sql,params] = builder.build_select()
+
+      rows = plv8.execute(sql,params)
+
+      builder = null  
+
+      if _query?.select?.indexOf('COUNT') > -1
+        result = rows
+      else
+        result = _.pluck(rows,'data')
+
+
+      return JSON.stringify(result)   
+
+    __upsert: (_schema_name, _table_name, _data) ->
+      # plv8.elog(NOTICE,"UPSERT",JSON.stringify(_data))
+    
+      return JSON.stringify(_data) if _data.errors?
+
+      data = _data
+
+      search_path = if _schema_name is "public" then _schema_name else "#{_schema_name},public"
+
+      if data.uuid?
+  
+        query =  { where: { uuid: data.uuid } }
+  
+        builder = new actn.Builder(_schema_name, _table_name, search_path, query )    
+
+        [sql,params] = builder.build_update(data)
+
+      else
+  
+        builder = new actn.Builder(_schema_name, _table_name, search_path, {})
+
+        [sql,params] = builder.build_insert(data)
+
+
+      # plan = plv8.prepare(sql, ['json','bool','text'])
+
+      # plv8.elog(NOTICE,sql,JSON.stringify(params))
+
+      rows = plv8.execute(sql, params)
+
+      result = _.pluck(rows,'data')
+
+      result = result[0] if result.length is 1
+ 
+      builder = null  
+
+      return JSON.stringify(result)  
+  
+    __update: (_schema_name, _table_name, _data, _cond) ->
+      return JSON.stringify(_data) if _data.errors?
+
+      search_path = if _schema_name is "public" then _schema_name else "#{_schema_name},public"
+
+      builder = new actn.Builder(_schema_name, _table_name, search_path, {where: _cond})
+
+      [sql,params] = builder.build_update(_data)
+
+      rows = plv8.execute(sql,params)
+      result = _.pluck(rows,'data')
+      result = result[0] if result.length is 1  
+
+      builder = null  
+
+      return JSON.stringify(result)  
+  
+    __delete: (_schema_name, _table_name, _cond) ->
+      search_path = if _schema_name is "public" then _schema_name else "#{_schema_name},public"
+
+      builder = new actn.Builder(_schema_name, _table_name, search_path, {where: _cond})
+
+      [sql,params] = builder.build_delete()
+
+      # plv8.elog(NOTICE,"DELETE",sql,params)
+
+      rows = plv8.execute(sql,params)
+      result = _.pluck(rows,'data')
+      result = result[0] if result.length is 1
+
+      builder = null  
+
+      return JSON.stringify(result)  
+  
+    __validate: (_name, _data) ->
+      data = _data
+
+      # plv8.elog(NOTICE,"__VALIDATE",_name,JSON.stringify(_data))
+
+      return data unless model = plv8.find_function('__find_model')(_name)
+
+      model = JSON.parse(model)
+
+      # plv8.elog(NOTICE,"__VALIDATE MODEL",_name,JSON.stringify(model))
+
+      if model?.schema?
+    
+        errors = actn.jjv.validate(model.schema,data)
+  
+        # plv8.elog(NOTICE,"VALVAL",JSON.stringify(model.schema))
+  
+        if data.uuid? and model.schema.readonly_attributes?
+    
+          data = _.omit(data,model.schema.readonly_attributes) 
+    
+          # plv8.elog(NOTICE,"VALIDATE READONLY",JSON.stringify(data),JSON.stringify(model.schema.readonly_attributes))
+
+    
+        else if model.schema.unique_attributes?
+    
+          _schema = if _name is "Model" then "core" else "public"
+          _table = model.name.tableize()    
+          __query = plv8.find_function("__query")
+    
+          for uniq_attr in model.schema.unique_attributes or []
+            if data[uniq_attr]?
+              where = {}
+              where[uniq_attr] = data[uniq_attr]
+              # plv8.elog(NOTICE,"VALIDATE WHERE",JSON.stringify({where: where}))
+              found = JSON.parse(__query(_schema,_table,{where: where}))
+              # plv8.elog(NOTICE,"VALIDATE FOUND",JSON.stringify(found))
+              unless _.isEmpty(found)
+                errors ?= {validation: {}}
+                errors['validation'][uniq_attr] ?= {}
+                errors['validation'][uniq_attr]["has already been taken"] = true
+  
+        data = {errors: errors} if errors?    
+
+      # plv8.elog(NOTICE,"__VALIDATE DATA",_name,JSON.stringify(data))
+  
+      return data  
+
+    __find_model: (_name) ->
+      rows = plv8.execute("""SET search_path TO core,public; 
+      SELECT data FROM core.models 
+      WHERE __string(data,'name'::text) = $1::text""", [_name])
+
+      return unless rows?
+
+      result = _.pluck(rows,'data')[0]
+
+      return JSON.stringify(result)  
+  
+    model_callbacks: (TG_OP, NEW, OLD) ->
+      table_name = (NEW?.data?.name or OLD?.data?.name)?.tableize()
+      table_schema = (NEW?.data?.table_schema or OLD?.data?.table_schema) or "public"
+
+      return if table_schema is "core"
+
+      # plv8.elog(NOTICE,"MODEL CALLBACKS",table_schema,JSON.stringify(NEW?.data or OLD?.data))
+
+      mapper = (ind) -> _.keys(ind.cols)
+      differ = (_ind) ->
+        (ind) ->  
+          _.isEmpty( _.difference( _.keys(ind.cols), _.flatten( _.map( _ind.data?.indexes, mapper ) ) ) )
+
+      switch TG_OP
+        when "INSERT"
+          plv8.execute "SELECT __create_table($1,$2)",[table_schema , table_name]
+    
+          plv8.execute "SELECT __create_index($1,$2,$3)", [table_schema, table_name, {cols: {path: "text" }}]
+    
+          for indopts in NEW?.data?.indexes or []
+            plv8.execute "SELECT __create_index($1,$2,$3)", [table_schema, table_name, indopts]
+      
+        when "UPDATE"
+      
+          diff  = _.reject( OLD?.data?.indexes, differ(NEW) )
+    
+          for indopts in diff
+            plv8.execute "SELECT __drop_index($1,$2,$3)", [table_schema, table_name, indopts]
+      
+          diff  = _.reject( NEW?.data?.indexes, differ(OLD) )
+    
+          for indopts in diff
+            plv8.execute "SELECT __create_index($1,$2,$3)", [table_schema, table_name, indopts]
+      
+        when "DELETE"
+          for indopts in Old?.data?.indexes or []
+            plv8.execute "SELECT __drop_index($1,$2,$3)", [table_schema, table_name, indopts]
+          plv8.execute "SELECT __drop_table($1,$2)",[table_schema , table_name]  
+
+    hook_trigger: (TG_TABLE_NAME, TG_OP, NEW, OLD) ->
+      upsert_func = plv8.find_function("__upsert")
+      model = JSON.parse(plv8.find_function("__find_model")(TG_TABLE_NAME.classify()))
+
+      callback  = {
+        INSERT: "after_create"     
+        UPDATE: "after_update"
+        DELETE: "after_destroy"
+      }[TG_OP]  
+  
+      # plv8.elog(NOTICE,"HOOK TRIGGER",JSON.stringify(model))
+  
+      for hook in model?.hooks?[callback] or []
+        hook.run_at ?= new Date()
+        hook.callback = callback
+    
+        job = 
+          hook: hook
+          table_name: TG_TABLE_NAME
+          record_uuid: NEW?.data?.uuid or OLD?.data?.uuid  
+          record: OLD.data if TG_OP is "DELETE"
+    
+        res = upsert_func "core", "jobs", JSON.stringify(job)
+        plv8.execute "SELECT pg_notify('jobs', $1);", [res]      
+
+    jobs_model_callbacks: (TG_TABLE_NAME, TG_OP, NEW, OLD) ->
+      table_name = (NEW?.data?.name or OLD?.data?.name).tableize()
+
+      table_schema = (NEW?.data?.table_schema or OLD?.data?.table_schema) or "public"
+
+      return if table_schema is "core"
+
+      if TG_OP is "DELETE"
+        plv8.execute "DELETE FROM core.jobs WHERE __string(data, 'table_name'::text) = $1;", [table_name]
+
+      # if TG_OP is "DELETE" and OLD.data.hooks? or TG_OP is "UPDATE" and NEW.data.hooks?
+      #   plv8.execute "DROP TRIGGER IF EXISTS #{table_schema}_#{table_name}_hook_trigger ON #{table_schema}.#{table_name}"
+
+  
+      if TG_OP is "INSERT" or TG_OP is "UPDATE" and NEW.data.hooks? and not OLD.data.hooks?
+        plv8.execute """CREATE TRIGGER #{table_schema}_#{table_name}_hook_trigger 
+                      AFTER INSERT OR UPDATE OR DELETE ON #{table_schema}.#{table_name} 
+                      FOR EACH ROW EXECUTE PROCEDURE hook_trigger();"""
+
+
+  root.actn.funcs = new Funcs
+  
+).call this