Using the mcpher library in your code

/**
 * @static
 */
var dbSilo;

function createDbSilos(optionalDb){
  return dbSilo ? 
      dbSilo : 
      (dbSilo = new cScriptDbSilo(optionalDb));
}
function librarySiloDb() {
  return ScriptDb.getMyDb();
}
/**
 * a cScriptDbSilo
 * @class 
 * @param {ScriptDbInstance} Db the default scriptDB
 * @implements {cScriptDbSilo}
 * @return {cScriptDbSilo} a new cScriptDbSilo
 */
function cScriptDbSilo(optionalDb) {
// create a Silo for known script silos
  this.xSilos = new collection();
  this.silos = function () {
    return this.xSilos;
  };

  this.xDb = IsMissing(optionalDb) ?  librarySiloDb() : optionalDb;
 
  return this;
}
/**
 * return the db silo item associated with the given key
 * @param {string} k the key
 * @param {ScriptDbInstance=} optionalDb the default scriptDB (default the db for the silo collection)
 * @param {boolean=} createIfUnknown whether to create the item if it doesnt exist (default true)
 * @param {boolean=} optionalHash whether to encrypt the userstamp
 * @param {boolean=} optionalMeOnly whether to filter by only records that I created
 * @return {cScriptDbSiloItem} the cScriptDbSiloItem
 */
function scriptDbSilo(k,optionalDb,createIfUnknown,optionalHash,optionalMeOnly) {
// find the Silo associated with this key

    // get the item or create it
    var dbSilo = createDbSilos(optionalDb);
    if (IsMissing(k)) 
      return dbSilo;
    else {
      var silo = dbSilo.silos().item(k,false);
    // return the SiloItem, or create one if it's allowed
      return silo ? silo : (fixOptional (createIfUnknown,true) ?  dbSilo.init(k,optionalDb,optionalHash,optionalMeOnly) : null) ;
    }
}
/**
 * add db silo item associated with the given key
 * @param {string} k the key
 * @param {ScriptDbInstance=} optionalDb the default scriptDB (default the db for the silo collection)
 * @param {boolean=} optionalHash whether to encrypt the userstamp
 * @param {boolean=} optionalMeOnly whether to filter by only records that I created
 * @return {cScriptDbSiloItem} the cScriptDbSiloItem
 */
cScriptDbSilo.prototype.init = function (k,optionalDb,optionalHash,optionalMeOnly) {
  return this.silos().add (new cScriptDbSiloItem(k,this,optionalDb,optionalHash,optionalMeOnly),k);
};
/**
 * remove all db silo items for this db
 * @param {object} ob the query by example object
 * @param {ScriptDbInstance=} optionalDb the default scriptDB (default the db for the silo collection)
 * @return {cScriptDbSilo} the cScriptDbSilo
 */
cScriptDbSilo.prototype.remove = function (ob,optionalDb) {
  return this.removeData(ob,optionalDb);
}

/**
 * remove db silo item data associated with the given query object
 * @param {object} ob the query by example object
 * @param {ScriptDbInstance=} optionalDb the default scriptDB (default the db for the silo collection)
 * @return {cScriptDbSilo} the cScriptDbSilo
 */
cScriptDbSilo.prototype.removeData = function (ob,optionalDb) {
    var qob = fixOptional(ob,{});
    //-- disabled for now---only allowed to delete your own data
    //qob.userStamp = Session.getUser().getEmail();
    //if (this.xHash) qob.userStamp = shortKeyHash(qob.userStamp);
    var db = fixOptional(optionalDb, this.xDb);
    
    // we'll use removeBatch
    while(true) {
      var result = db.query(qob); // get everything, up to limit
      if (result.getSize() == 0) {
        break;
      }
      var o = [];
      while (result.hasNext()) {
        if (o.length > this.xBatchMax) {
          DebugAssert(db.allOk(db.removeBatch(o, false)), "failed to delete " + o.length + " objects"); 
          o = [];
        }
        o.push(result.next());
      }
      
      if (o.length > 0 ) {
        var result = db.removeBatch(o, false);
        DebugAssert(db.allOk(result), "failed to delete " + o.length + " objects"); 
      }
    }
  
  return this;
}

/**
 * fill the silos from the data in the script DB
 * @param {object} ob the query by example object
 * @param {ScriptDbInstance=} optionalDb the default scriptDB (default the db for the silo collection)
 * @return {cScriptDbSilo} the cScriptDbSilo
 */
cScriptDbSilo.prototype.fill = function (optionalDb) {
// fill Silo with every known silo  in the given db
    var db = fixOptional ( optionalDb, this.xDb);
    var result = db.query({}); //note-- only works up to the limit

      while (result.hasNext()) {
        var k = result.next().siloId;
        if ( ! this.Silos.item(k,false) ) 
          this.Silos().add (new cScriptDbSiloItem(k,this,db),k ); 
      }

  return this;
};
/**
 * a cScriptDbSiloItem
 * @class 
 * @param {string} k the key
 * @param {cScriptDbSilo=} parent the collection of silo items
 * @param {boolean=} optionalHash whether to encrypt the userstamp
 * @param {boolean=} optionalMeOnly whether to filter by only records that I created
 * @implements {cScriptDbSiloItem}
 * @return {cScriptDbSiloItem} a new cScriptDbSiloItem
 */

function cScriptDbSiloItem(k,parent,optionalDb,optionalHash,optionalMeOnly) {
  // a silo item
  this.xBatch = [];
  this.xKey = makeKey(k);
  this.xParent = parent;
  this.xHash = fixOptional( optionalHash, false);
  this.xMeOnly = fixOptional( optionalMeOnly, false);
  this.xDb = fixOptional( optionalDb , this.xParent.xDb);
  this.db = function() {
    return this.xDb;
  }
  // this is wont change in a silo session so may as well do it once
  this.xWho = this.who();
  // there is a bug in savebatch that failes for more than about 4000
  // here's a workaround
  this.xBatchMax = 4000;
  return this;
}
/**
 * construct the query object that identifies this query by example
 * @param {object=} ob the query by example (default all data)
 * @return {object}  a query by example to silo the data
 */
cScriptDbSiloItem.prototype.querySet = function(ob) {
  // apply a query for this silo
  var newOb = fixOptional(ob,{});
  newOb.siloId = this.xKey;
  if (!newOb.userStamp && this.xMeOnly) newOb.userStamp = this.xWho;
  return newOb ;
};
cScriptDbSiloItem.prototype.queryStamp = function(ob) {
  // apply a user and time stamp
  ob.timeStamp = new Date().getTime();
  ob.userStamp = this.xWho;
  return ob;
};
/**
 * do a query within the silo for this cScriptDbSiloItem
 * @param {object} [ob={}]  the query by example (default all data)
 * @param {object} [ob={}]  the query by example (default all data)
 * @return {ScriptDBquery} a query by example to silo the data
 */
cScriptDbSiloItem.prototype.query = function(ob) {
  return this.db().query(this.querySet(ob));
};
/**
 * do a query within the silo and put to an array, taking account of limits
 * @param {object} [ob={}]  the query by example (default all data)
 * @param {object} [ob={}]  the query by example (default all data)
 * @param {number} [optLimit=0]  default bypass any limits
 * @return {Array} an array of results
 */
cScriptDbSiloItem.prototype.queryArray = function(ob, optLimit) {
  
  // this is the max I'll take in one go to be compatible with parse.com
  var maxLimit = 1000;
  var limit = fixOptional ( optLimit, 0);
  var results =[], q = this.querySet(ob);
  while(true) {
    var qr =  this.db()
                .query(q)
                .limit(limit > 0 ? limit-results.length : maxLimit).startAt(results.length);
    // we're done
    if (!qr.hasNext()) return results;
    // still have pushing to do
    while(qr.hasNext() && (limit==0 || results.length < limit)) results.push(qr.next());
  }
  
};
/**
 * do a count query within the silo for this cScriptDbSiloItem
 * @param {object} [ob={}] the query by example (default all data)
 * @return {ScriptDBquery} a query by example to silo the data
 */
cScriptDbSiloItem.prototype.count = function(ob) {
  return this.db().count(this.querySet(ob));
};
/**
 * do a save within the silo for this cScriptDbSiloItem
 * @param {object} ob the data so save
 * @param {boolean} optBatch whether or not to save up for a batch update
 * @return {ScriptDbResult} a query result 
 */
cScriptDbSiloItem.prototype.save = function(ob,optBatch) {
  var sob = this.queryStamp(this.querySet(ob));
  if (fixOptional (optBatch, false)) {
    if (this.batchLength() > this.xBatchMax) {
      this.saveBatch();
    }
    this.xBatch.push(sob);
  }
  else
    return this.db().save(sob);
};
/**
 * provide current batch length 
 * @return {number} the batch length
 */
cScriptDbSiloItem.prototype.batchLength = function() {
  return this.xBatch ? this.xBatch.length : 0;
};
/**
 * clear out any batch items
 * @return {ScriptDbResult} a query result 
 */
cScriptDbSiloItem.prototype.saveBatch = function() {
   if (this.xBatch.length) {
     var results = this.db().saveBatch(this.xBatch, false);
     this.xBatch = [];
     return results;
   }
   else 
     return null;   
};
/**
 * do a save within the silo for this cScriptDbSiloItem, and delete the data
 * @param {object=} ob the data so remove (default all data for this silo)
 * @return {cScriptDbSiloItem} the cScriptDbSiloItem
 */
cScriptDbSiloItem.prototype.remove = function(ob) {
  return this.xParent.removeData(this.querySet(ob),this.db());
};
/**
 * get who user is, and hash email address if required
 * @param {boolean=} optHash whether to encrypt, otherwise use the silo default
 * @return {string} the user email or hashed emaik
 */
cScriptDbSiloItem.prototype.who = function(optHash) {
  return fixOptional(optHash, this.xHash) ? shortKeyHash(Session.getUser().getEmail()) : Session.getUser().getEmail();
};
/**
 * return the stuff from the db associated with the e.parameter.entry value
 * @param {String} siloNamethe the locker name
 * @param {scriptDB} db the private db to use
 * @return {ContentService} the rest response
 */
function getMyStuff (siloName, db) {

    var response = {status: {code:"bad", reason:"entry parameter not found"}, result:null};
    var silo = scriptDbSilo(siloName,db);
    var thisMail = silo.who();
    
    if (!db) {
      response.reason = "private db must be specified" ;
    }
    else if (siloName) 
    { var q=  silo.query();
      if (q.hasNext()) {
        // only retrievable by teh same user as created it
        var result = q.next();
        try {
           if (result.userStamp != thisMail) {
             response.status.code = "bad";
             response.status.reason = siloName + "does not belong to you";
           }
           else {
             response.status.code = "good";
             response.status.reason = siloName + " found in your stuff";
             response.result = result;
           }
             
          }
          catch (err) {
            response.status.code = "bad";
            response.status.reason = err;
          }
      } 
      else {
        response.status.code = "bad";
        response.status.reason = siloName + " not found in your stuff";
      }
    }

    return response;
}
/**
 * create an entry for the given siloname value
 * @param {String} siloNamethe the locker name
 * @param {scriptDB} db the private db to use
 * @param {object} content the content to store
 * @return {scriptDBObject} the saved object
 */
function createStuff (siloName, db, content) {
  // exist?
  DebugAssert(db, "you must provide a db");
  var silo =  scriptDbSilo(siloName,db);
  var myAuth = silo.query();
  if (myAuth.hasNext()) silo.remove();
  var put = {};
  put.myStuff = content;
  put.help = "for details see ramblings.mcpher.com";
  return silo.save(put);
}
/** react to a doGet(e) using lockbox for oAuth
 * @param {object} e as passed to doGet() (show or oauth)
 * @param {scriptDBInstance} db the private db to use
 * @return {String} the json string content
 */
function getStuffContent (e,db) {
   //parameters 
   // e.parameter.entry - the lockBox entry name
   // e.parameter.proxyUrl - optional - if specifed then proxyUrl to execute , using lockbox entry for oAuth 
   // e.parameter.action - manadatory - (not implemented yet edit,)show,oauth

  var content ="";
  if(IsMissing(db)) 
    content = JSON.stringify ({error: "programming error - you must provide a scriptDB to use"}) ;
 else {
    var entry =  decodeURIComponent(e.parameter.entry)
    var proxyurl = decodeURIComponent(e.parameter.proxyurl) ;
    var action = decodeURIComponent(e.parameter.action);
    

    try {
  
      switch (action) {
        case 'edit':
          content= JSON.stringify ({error: "action not yet implemented" + action}) ;
          break;
          //TODO return uiStuff (db, entry);
          
        case 'show':
          content = JSON.stringify(getMyStuff(entry,db));
          break;
          
        case 'oauth':
          content = oAuthProxy (db,entry, proxyurl).getContentText();
          break;
          
        default:
          content = JSON.stringify ({error: "unknown action - should be show or oauth" + action}) ;
          break;
      } 
    }
    catch (err) {
        content = JSON.stringify ( { error: err } );
    }
   
   
   }
   return content;
  
}
/**
 * oAuthPacket will create a packet of options and oauth parameters
 * @param {object} stuff contents of an oauth lockbox
 * @return {urlfetch.advancedoptions} the packet to use as options to urlfetch
 */ 
function oAuthPacket(stuff) {

  // relevant properties from silo
    var locker = stuff.result.myStuff;
    var siloId = stuff.result.siloId;
    
  // use GAS oauth library
    var oa = UrlFetchApp.addOAuthService(siloId);
    oa.setAccessTokenUrl (locker.accessUrl);
    oa.setRequestTokenUrl (locker.requestUrl);
    oa.setAuthorizationUrl(locker.authorizeUrl);
    oa.setConsumerKey(locker.consumerKey);
    oa.setConsumerSecret(locker.consumerSecret);
  
  // advanced oauth options
    return {
      "oAuthServiceName": siloId,
      "oAuthUseToken" : "always"
     };
}
/**
 * oAuthProxy will execute an oauth then call some url by proxy
 * @param {String} siloId siloid of the scriptdb locker holding the oauth information
 * @param {scriptDBInstance} db the private db to use
 * @param {String} url to execute
 * @return {String} response from the urlfetch
 */                
function oAuthProxy (db,siloId, url) {

  // get myStuff - this will have previously been stored in the myStuff locker
  var stuff = getMyStuff(siloId,db);
  DebugAssert(stuff.status.code == "good", "error getting secrets " + JSON.stringify(stuff) );

  // construct the oauth packet
  var packet = oAuthPacket(stuff);
  
  // issue request
   return UrlFetchApp.fetch(url, packet);
  
}
/**
 * return the stuff from the db associated with the e.parameter.entry value
 * @param {String} siloNamethe the locker name
 * @param {scriptdbinstance} db public db
 * @param {queryOb} optQuery optional query by example
 * @return {ContentService} the rest response
 */
function getPubStuff (siloName, db, optQuery) {
  var q;

  var response = {status: {code:"bad", reason:"unknown error"}, results:null};
  var ob = optQuery || {}; 
  
  q=  siloName ? scriptDbSilo(siloName,db).query(ob) : db.query(ob);
  if (q.hasNext()) {
    response.status.code = "good";
    response.status.reason = siloName + " found in your stuff";
    response.results =  [] ;
    while (q.hasNext()) {
      response.results.push(q.next());
    }
  }
  else {
    response.status.reason = siloName + " has no data";
    response.status.query = JSON.stringify(ob);
  }   
  return response;
}

/** react to a doGet(e) to return public data
 * @param {object} e as passed to doGet() 
 * @param {scriptdbinstance} db public db
 * @return {String} the json string content
 */
function getPubStuffContent (e,db) {
   //parameters 
   // e.parameter.entry - optional the lockBox entry name
  var content ;
  var entry =  e.parameter && e.parameter.entry ? decodeURIComponent(e.parameter.entry)  : null;
  try {
          content = JSON.stringify(getPubStuff(entry,db));
  } 
  catch (err) {
        content = JSON.stringify ( { error: err } );
  }

   return content;
  
}

/** show everything in a given db
 * @param {scriptdbinstance} db public db
 * @return {String} the json string content
 */
function showAll(db) {
  var results = db.query({});

  while (results.hasNext()) {
    var result = results.next();
    Logger.log(Utilities.jsonStringify(result));
  }
}