actn-db 0.0.1 → 0.0.2

data/db/__setup.sql

@@ -2,7 +2,6 @@
 
 CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
 CREATE EXTENSION IF NOT EXISTS "plv8";
-CREATE EXTENSION IF NOT EXISTS "plcoffee";
 
 
 
@@ -14,24 +13,27 @@ CREATE TABLE plv8_modules(modname text primary key, load_on_start boolean, code
 
 CREATE OR REPLACE FUNCTION plv8_startup() RETURNS void AS $$
   
-  load_module = (modname) ->
-    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++
-    return
-
-
-  # now load all the modules marked for loading on start
-  rows = plv8.execute("SELECT modname, code from public.plv8_modules where load_on_start")
-  r = 0
-
-  while r < rows.length
-    code = rows[r].code
-    eval("(function(){" + code + "})")()
-    r++  
+  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++;
+    }
+  };
+
+  rows = plv8.execute("SELECT modname, code from public.plv8_modules where load_on_start");
+
+  r = 0;
+
+  while (r < rows.length) {
+    code = rows[r].code;
+    eval("(function(){" + code + "})")();
+    r++;
+  }
     
-$$ LANGUAGE plcoffee STABLE STRICT;
+$$ LANGUAGE plv8 STABLE STRICT;

data/db/lib/_0_actn_f.coffee

@@ -0,0 +1,381 @@
+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();"""
+
+actn.funcs = new Funcs

data/db/lib/_0_actn_f.js

@@ -0,0 +1,403 @@
+// Generated by CoffeeScript 1.6.3
+(function() {
+  var Funcs;
+
+  Funcs = (function() {
+    function Funcs() {}
+
+    Funcs.prototype.__json = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return JSON.stringify(ret);
+    };
+
+    Funcs.prototype.__string = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return ret.toString();
+    };
+
+    Funcs.prototype.__integer = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return parseInt(ret);
+    };
+
+    Funcs.prototype.__integer_array = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return (ret instanceof Array ? ret : [ret]);
+    };
+
+    Funcs.prototype.__float = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return parseFloat(ret);
+    };
+
+    Funcs.prototype.__bool = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return !!ret;
+    };
+
+    Funcs.prototype.__timestamp = function(_data, _key) {
+      var ret;
+      ret = actn.valueAt(_data, _key);
+      if (ret == null) {
+        return null;
+      }
+      return new Date(ret);
+    };
+
+    Funcs.prototype.__patch = function(_data, _value, _sync) {
+      var changes, data, defaults, isObject, k, sync;
+      data = _data;
+      changes = _value;
+      isObject = false;
+      sync = _sync != null ? _sync : true;
+      defaults = _.pick(data, _.keys(JSON.parse(plv8.find_function('__defaults')())));
+      for (k in changes) {
+        if (data.hasOwnProperty(k)) {
+          isObject = typeof data[k] === "object" && typeof changes[k] === "object";
+          data[k] = isObject && sync ? _.extend(data[k], changes[k]) : changes[k];
+        } else {
+          data[k] = changes[k];
+        }
+      }
+      if (!sync) {
+        for (k in data) {
+          if (changes[k] == null) {
+            delete data[k];
+          }
+        }
+      }
+      _.extend(data, defaults);
+      return JSON.stringify(data);
+    };
+
+    Funcs.prototype.__select = function(_data, _fields) {
+      var data, fields, ret;
+      data = _data;
+      fields = _fields;
+      ret = _.pick(data, fields.split(","));
+      return JSON.stringify(ret);
+    };
+
+    Funcs.prototype.__push = function(_data, _key, _value) {
+      var data, field, i, keys, last_field, len, value;
+      data = _data;
+      value = _value;
+      keys = _key.split(".");
+      len = keys.length;
+      last_field = data;
+      field = data;
+      i = 0;
+      while (i < len) {
+        last_field = field;
+        if (field) {
+          field = field[keys[i]];
+        }
+        ++i;
+      }
+      if (field) {
+        field.push(value);
+      } else {
+        if (!(value instanceof Array)) {
+          value = [value];
+        }
+        last_field[keys.pop()] = value;
+      }
+      return JSON.stringify(data);
+    };
+
+    Funcs.prototype.__uuid = function() {
+      var ary;
+      ary = plv8.execute('SELECT uuid_generate_v4() as uuid;');
+      return JSON.stringify(ary[0]);
+    };
+
+    Funcs.prototype.__defaults = function() {
+      var timestamp, uuid;
+      uuid = JSON.parse(plv8.find_function('__uuid')());
+      timestamp = new Date();
+      return JSON.stringify({
+        uuid: uuid.uuid,
+        created_at: timestamp,
+        updated_at: timestamp
+      });
+    };
+
+    Funcs.prototype.__create_table = function(schema_name, table_name) {
+      plv8.execute("  CREATE TABLE " + schema_name + "." + table_name + " (\n  id serial NOT NULL,\n  data json DEFAULT __uuid() NOT NULL,\n  CONSTRAINT " + schema_name + "_" + table_name + "_pkey PRIMARY KEY (id));\n\n  CREATE UNIQUE INDEX indx_" + schema_name + "_" + table_name + "_unique_uuid ON " + schema_name + "." + table_name + " (__string(data,'uuid'));");
+      return JSON.stringify(table_name);
+    };
+
+    Funcs.prototype.__drop_table = function(schema_name, table_name) {
+      plv8.execute("DROP TABLE IF EXISTS " + schema_name + "." + table_name + " CASCADE;");
+      return JSON.stringify(table_name);
+    };
+
+    Funcs.prototype.__create_index = function(schema_name, table_name, optns) {
+      var cols, index_name, meth, name, sql, type, _ref, _ref1;
+      index_name = "indx_" + schema_name + "_" + table_name;
+      _ref = optns.cols;
+      for (name in _ref) {
+        type = _ref[name];
+        index_name += "_" + name;
+      }
+      sql = ["CREATE"];
+      if (optns.unique) {
+        sql.push("UNIQUE");
+      }
+      sql.push("INDEX");
+      if (optns.concurrently) {
+        sql.push("CONCURRENTLY");
+      }
+      sql.push("" + index_name + " on " + schema_name + "." + table_name);
+      sql.push("(");
+      cols = [];
+      _ref1 = optns.cols;
+      for (name in _ref1) {
+        type = _ref1[name];
+        meth = "__" + (type === 'text' ? 'string' : type);
+        cols.push("" + meth + "(data,'" + name + "'::" + type + ")");
+      }
+      sql.push(cols.join(","));
+      sql.push(")");
+      sql = sql.join(" ");
+      plv8.execute(sql);
+      return JSON.stringify(index_name);
+    };
+
+    Funcs.prototype.__drop_index = function(schema_name, table_name, optns) {
+      var index_name, name, type, _ref;
+      index_name = "indx_" + schema_name + "_" + table_name;
+      _ref = optns.cols;
+      for (name in _ref) {
+        type = _ref[name];
+        index_name += "_" + name;
+      }
+      plv8.execute("DROP INDEX IF EXISTS " + index_name);
+      return JSON.stringify(index_name);
+    };
+
+    Funcs.prototype.__query = function(_schema_name, _table_name, _query) {
+      var builder, params, result, rows, search_path, sql, _ref, _ref1;
+      search_path = _schema_name === "public" ? _schema_name : "" + _schema_name + ", public";
+      builder = new actn.Builder(_schema_name, _table_name, search_path, _query);
+      _ref = builder.build_select(), sql = _ref[0], params = _ref[1];
+      rows = plv8.execute(sql, params);
+      builder = null;
+      if ((_query != null ? (_ref1 = _query.select) != null ? _ref1.indexOf('COUNT') : void 0 : void 0) > -1) {
+        result = rows;
+      } else {
+        result = _.pluck(rows, 'data');
+      }
+      return JSON.stringify(result);
+    };
+
+    Funcs.prototype.__upsert = function(_schema_name, _table_name, _data) {
+      var builder, data, params, query, result, rows, search_path, sql, _ref, _ref1;
+      if (_data.errors != null) {
+        return JSON.stringify(_data);
+      }
+      data = _data;
+      search_path = _schema_name === "public" ? _schema_name : "" + _schema_name + ",public";
+      if (data.uuid != null) {
+        query = {
+          where: {
+            uuid: data.uuid
+          }
+        };
+        builder = new actn.Builder(_schema_name, _table_name, search_path, query);
+        _ref = builder.build_update(data), sql = _ref[0], params = _ref[1];
+      } else {
+        builder = new actn.Builder(_schema_name, _table_name, search_path, {});
+        _ref1 = builder.build_insert(data), sql = _ref1[0], params = _ref1[1];
+      }
+      rows = plv8.execute(sql, params);
+      result = _.pluck(rows, 'data');
+      if (result.length === 1) {
+        result = result[0];
+      }
+      builder = null;
+      return JSON.stringify(result);
+    };
+
+    Funcs.prototype.__update = function(_schema_name, _table_name, _data, _cond) {
+      var builder, params, result, rows, search_path, sql, _ref;
+      if (_data.errors != null) {
+        return JSON.stringify(_data);
+      }
+      search_path = _schema_name === "public" ? _schema_name : "" + _schema_name + ",public";
+      builder = new actn.Builder(_schema_name, _table_name, search_path, {
+        where: _cond
+      });
+      _ref = builder.build_update(_data), sql = _ref[0], params = _ref[1];
+      rows = plv8.execute(sql, params);
+      result = _.pluck(rows, 'data');
+      if (result.length === 1) {
+        result = result[0];
+      }
+      builder = null;
+      return JSON.stringify(result);
+    };
+
+    Funcs.prototype.__delete = function(_schema_name, _table_name, _cond) {
+      var builder, params, result, rows, search_path, sql, _ref;
+      search_path = _schema_name === "public" ? _schema_name : "" + _schema_name + ",public";
+      builder = new actn.Builder(_schema_name, _table_name, search_path, {
+        where: _cond
+      });
+      _ref = builder.build_delete(), sql = _ref[0], params = _ref[1];
+      rows = plv8.execute(sql, params);
+      result = _.pluck(rows, 'data');
+      if (result.length === 1) {
+        result = result[0];
+      }
+      builder = null;
+      return JSON.stringify(result);
+    };
+
+    Funcs.prototype.__validate = function(_name, _data) {
+      var data, errors, found, model, uniq_attr, where, __query, _base, _i, _len, _ref, _schema, _table;
+      data = _data;
+      if (!(model = plv8.find_function('__find_model')(_name))) {
+        return data;
+      }
+      model = JSON.parse(model);
+      if ((model != null ? model.schema : void 0) != null) {
+        errors = actn.jjv.validate(model.schema, data);
+        plv8.elog(NOTICE, "VALVAL", JSON.stringify(model.schema));
+        if ((data.uuid != null) && (model.schema.readonly_attributes != null)) {
+          data = _.omit(data, model.schema.readonly_attributes);
+        } else if (model.schema.unique_attributes != null) {
+          _schema = _name === "Model" ? "core" : "public";
+          _table = model.name.tableize();
+          __query = plv8.find_function("__query");
+          _ref = model.schema.unique_attributes || [];
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            uniq_attr = _ref[_i];
+            if (data[uniq_attr] != null) {
+              where = {};
+              where[uniq_attr] = data[uniq_attr];
+              found = JSON.parse(__query(_schema, _table, {
+                where: where
+              }));
+              if (!_.isEmpty(found)) {
+                if (errors == null) {
+                  errors = {
+                    validation: {}
+                  };
+                }
+                if ((_base = errors['validation'])[uniq_attr] == null) {
+                  _base[uniq_attr] = {};
+                }
+                errors['validation'][uniq_attr]["has already been taken"] = true;
+              }
+            }
+          }
+        }
+        if (errors != null) {
+          data = {
+            errors: errors
+          };
+        }
+      }
+      return data;
+    };
+
+    Funcs.prototype.__find_model = function(_name) {
+      var result, rows;
+      rows = plv8.execute("SET search_path TO core,public; \nSELECT data FROM core.models \nWHERE __string(data,'name'::text) = $1::text", [_name]);
+      if (rows == null) {
+        return;
+      }
+      result = _.pluck(rows, 'data')[0];
+      return JSON.stringify(result);
+    };
+
+    Funcs.prototype.model_callbacks = function(TG_OP, NEW, OLD) {
+      var diff, differ, indopts, mapper, table_name, table_schema, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref, _ref1, _ref10, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9, _results, _results1;
+      table_name = (_ref = (NEW != null ? (_ref1 = NEW.data) != null ? _ref1.name : void 0 : void 0) || (OLD != null ? (_ref2 = OLD.data) != null ? _ref2.name : void 0 : void 0)) != null ? _ref.tableize() : void 0;
+      table_schema = ((NEW != null ? (_ref3 = NEW.data) != null ? _ref3.table_schema : void 0 : void 0) || (OLD != null ? (_ref4 = OLD.data) != null ? _ref4.table_schema : void 0 : void 0)) || "public";
+      if (table_schema === "core") {
+        return;
+      }
+      mapper = function(ind) {
+        return _.keys(ind.cols);
+      };
+      differ = function(_ind) {
+        return function(ind) {
+          var _ref5;
+          return _.isEmpty(_.difference(_.keys(ind.cols), _.flatten(_.map((_ref5 = _ind.data) != null ? _ref5.indexes : void 0, mapper))));
+        };
+      };
+      switch (TG_OP) {
+        case "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"
+              }
+            }
+          ]);
+          _ref6 = (NEW != null ? (_ref5 = NEW.data) != null ? _ref5.indexes : void 0 : void 0) || [];
+          _results = [];
+          for (_i = 0, _len = _ref6.length; _i < _len; _i++) {
+            indopts = _ref6[_i];
+            _results.push(plv8.execute("SELECT __create_index($1,$2,$3)", [table_schema, table_name, indopts]));
+          }
+          return _results;
+          break;
+        case "UPDATE":
+          diff = _.reject(OLD != null ? (_ref7 = OLD.data) != null ? _ref7.indexes : void 0 : void 0, differ(NEW));
+          for (_j = 0, _len1 = diff.length; _j < _len1; _j++) {
+            indopts = diff[_j];
+            plv8.execute("SELECT __drop_index($1,$2,$3)", [table_schema, table_name, indopts]);
+          }
+          diff = _.reject(NEW != null ? (_ref8 = NEW.data) != null ? _ref8.indexes : void 0 : void 0, differ(OLD));
+          _results1 = [];
+          for (_k = 0, _len2 = diff.length; _k < _len2; _k++) {
+            indopts = diff[_k];
+            _results1.push(plv8.execute("SELECT __create_index($1,$2,$3)", [table_schema, table_name, indopts]));
+          }
+          return _results1;
+          break;
+        case "DELETE":
+          _ref10 = (typeof Old !== "undefined" && Old !== null ? (_ref9 = Old.data) != null ? _ref9.indexes : void 0 : void 0) || [];
+          for (_l = 0, _len3 = _ref10.length; _l < _len3; _l++) {
+            indopts = _ref10[_l];
+            plv8.execute("SELECT __drop_index($1,$2,$3)", [table_schema, table_name, indopts]);
+          }
+          return plv8.execute("SELECT __drop_table($1,$2)", [table_schema, table_name]);
+      }
+    };
+
+    return Funcs;
+
+  })();
+
+  actn.funcs = new Funcs;
+
+}).call(this);