DriverProperties

This is the the driver for DB.PROPERTIES described in Database abstraction with google apps script
The library reference is

MrpyO-B3fO-b1NG3LZ4UzaKi_d-phDA33

Reference

This driver uses one of objects returned by the Google Apps Script Properties service. It is only usable for small databases, since there is a limit on property size, but is has all the same features (query/update/sort/limit/get/remove/save) as the other drivers and caching and locking are implemented.
The siloId is the property key, and the object to pass is the property object to use. 
Here’s how to get a handler.

var propertiesHandler = new cDataHandler.DataHandler('avengers',cDataHandler.dhConstants.DB.PROPERTIES,undefined, 'myproperties',UserProperties);

Example

This example gets some data from Driver Import.io, writes it as a database to both a drive JSON file and the user properties, and does a couple of queries on the result. 

function driveTest6() {


var importioHandler = new cDataHandler.DataHandler
('caff10dc-3bf8-402e-b1b8-c799a77c3e8c',cDataHandler.dhConstants.DB.IMPORTIO,
undefined,'myimportio',JSON.parse(UserProperties.getProperty("importioKeys"))); 
var importioData = importioHandler.query({searchterm: "avengers 2"},undefined,1);
if (importio.handleCode <0) throw (JSON.stringify(importioData));

// write to a property
var propertiesHandler = new cDataHandler.DataHandler('avengers',cDataHandler.dhConstants.DB.PROPERTIES,undefined, 'myproperties',UserProperties); 
propertiesHandler.remove();
var result = propertiesHandler.save (importioData.data);
if (result.handleCode <0) throw (JSON.stringify(result));
Logger.log(propertiesHandler.query(undefined,{limit:2,sort:'skills'},1));


// write to a drive
var driveHandler = new cDataHandler.DataHandler('avengers.json',cDataHandler.dhConstants.DB.DRIVE,undefined,'/datahandler/driverdrive'); 
driveHandler.remove();
var result = driveHandler.save (importioData.data);
if (result.handleCode <0) throw (JSON.stringify(result));
Logger.log(driveHandler.query(undefined,{limit:2,sort:'skills'},1));

}

The Code

function createDriver (handler,siloId,driverSpecific,driverOb, accessToken) {
    return new DriverProperties(handler,siloId,driverSpecific,driverOb, accessToken);
}
function getLibraryInfo () {
  return {
    info: {
      name:'cDriverProperties',
      version:'2.0.2',
      key:'MrpyO-B3fO-b1NG3LZ4UzaKi_d-phDA33',
      share:"https://script.google.com/d/17Nh1LJKElibaoj9EvpX9s1m_vMvOG2qJN24Le-W01wtRCqc1wdHWVonC/edit?usp=sharing",
      description:"properties driver for dbabstraction"
    },
    dependencies:[
      cDriverMemory.getLibraryInfo(),
      cDelegateMemory.getLibraryInfo()
    ]
  }; 
}
/**
 * DriverProperties
 * @param {cDataHandler} handler the datahandler thats calling me
 * @param {string} keyName this is keyname in the properties ob
 * @param {string} id some id you create for identifying this collection - normally the folder path
 * @param {object} PropertiesOb the properties ob to use
 * @return {DriverProperties} self
 */

// this can be used for small datasets in place of a database
// a JSON object is stored as a Drive file and can be manipulated to provide database like characterisitcs
// data is stored as [ {key:someuniquekey, data:{},...]
 
var DriverProperties = function (handler,keyName,id,PropertiesOb) {
  var siloId = keyName;
  var dbId = id;
  var self = this;
  var parentHandler = handler;
  var enums = parentHandler.getEnums();  
  var keyOb = PropertiesOb;
  var handle, handleError, handleCode , handleIds, handleKey; 
  var transactionBox_ = null;
  
  // im able to do transactions
  self.transactionCapable = true;
  
  // i definitely need transaction locking
  self.lockingBypass = false;
  
  // i am aware of transactions and know about the locking i should do
  self.transactionAware = true;
  
 /**
  * checks that the transaction matches the one stored
  * @param {string} id transaction id
  * @return {boolean} whether id matches
  */ 
  self.isTransaction = function (id) {
    return transactionBox_ &amp;&amp; transactionBox_.id === id ;
  };
  
 /**
  * begins transaction and store current content
  * @param {string} id transaction id
  */ 
  self.beginTransaction = function (id) {
    transactionBox_ = delegate.beginTransaction (id);
  };
  
  self.transactionData = function (){
    return delegate.transactionData();
  };
  
  /**
  * commits transaction
  * @param {string} id transaction id
  * @return {object} a normal result package
  */ 
  self.commitTransaction = function (id) {
    return delegate.commitTransaction(id);
  };
  
  self.clearTransactionBox = function () {
    transactionBox_ = null;
  };
  
 /**
  * roll back transaction - resets memory to beginnging of transaction
  * @param {string} id transaction id
  * @return {object} a normal result package
  */ 
  self.rollbackTransaction = function (id) {
    return delegate.rollbackTransaction(id);
  };
  
  
  self.getTransactionBox = function () {
    return transactionBox_;
  };
  
  self.getSiloId = function () {
    return siloId;
  };
  
  self.getParentHandler = function () {
    return parentHandler;
  };
  
  self.getType = function () {
    return enums.DB.PROPERTIES;
  };
  
  /** each saved records gets a unique key
   * @return {string} a unique key
   */
  self.generateKey = function () {
    return parentHandler.generateUniqueString();
  };
  
  self.getDbId = function () {
    return dbId;
  };
  handle = keyOb;
  
  var delegate = new cDelegateMemory.DelegateMemory(self);
  
  /** 
   * @return {DriverProperties} the folder for the file
   */
  self.getDriveHandle =  function () {
    return handle;
  };

  
 /** set the contents to the property, creating it if necessary
  * @param {string} json content
  * @return {File} the existing or created property
  */
  self.writeContent = function (content) {
    handle.setProperty(siloId, JSON.stringify(content)) ;
    return parentHandler.makeResults(enums.CODE.OK);
  };
  
 /** get the contents of the property
  * @return {object} the parsed content of the file
  */
  self.getContent= function () {
    var file = handle.getProperty(siloId);
    return file ? delegate.getContentSimpleKeys( JSON.parse(file) ) : null;

  };

  /**
   * get the memory - if its a transaction we already have it, if not read the sheet and make one
   * @return {DriverMemory} the men object
   */
  self.getMem = function () {
       
    return parentHandler.inTransaction() ? 
      transactionBox_.content :
      self.take(new cDriverMemory.DriverMemory(parentHandler, siloId)) ;
  
  };
  
    
  /**
   * --------------------------------
   * DriverSheet.replace ()
   * replaces current sheet with whats in memory
   * @param {DriverMemory} mem to be saved
   * @return {Object} headingOb with indexes
   */
  self.replaceWithMemory = function (mem) {
    return self.putBack(mem);
  };
  
  self.putBack = function (mem) {
    return delegate.putBackSimpleKeys(mem);
  };
  
  self.take = function (mem) {
    return mem.makeContent ( 
      parentHandler.rateLimitExpBackoff ( function () { 
        return (self.getContent() || []);
      }));
  }; 
  
 /** create the driver version
  * @return {string} the driver version
  */ 
  self.getVersion = function () {
    var v = getLibraryInfo().info;
    return v.name + ':' + v.version;
  };
  
  /**
   * DriverProperties.getTableName()
   * @return {string} table name or silo
   */
  self.getTableName = function () {
    return siloId;
  };
  

  self.query = function (queryOb,queryParams,keepIds) {
    return delegate.query(queryOb,queryParams,keepIds);
  };


  /**
   * DriverProperties.remove()
   * @param {object} queryOb some query object 
   * @param {object} queryParams additional query parameters (if available)
   * @return {object} results from selected handler
   */
  self.remove = function (queryOb,queryParams) {
    return delegate.remove(queryOb,queryParams);
  };
     
  /**
   * DriverProperties.save()
   * @param {Array.object} obs array of objects to write
   * @return {object} results from selected handler
   */
  self.save = function (obs) {
    return delegate.save(obs, self.getMem());
  };
  
  /**
   * DriverProperties.count()
   * @param {object} queryOb some query object 
   * @param {object} queryParams additional query parameters (if available)
   * @return {object} results from selected handler
   */
  self.count = function (queryOb,queryParams) {
     return delegate.count(queryOb,queryParams);
  };
  
    
  /**
   * DriverProperties.get()
   * @param {string} keys the unique return in handleKeys for this object
   * @return {object} results from selected handler
   */
  self.get = function (keys) {
   return delegate.get (keys);
  };
  
  self.getGuts = function (keys) {
    return self.getMem().get ( keys,true,'key')
  };
  
  /**
   * DriverMemory.removeById()
   * @param {string} keys key to remove
   * @return {object} results from selected handler
   */ 
  self.removeByIds = function (keys) {
    return delegate.removeByIds (keys,'key');
  };
  
   /**
   * DriverProperties.update()
   * @param {string} keys the unique return in handleKeys for this object
   * @param {object} obs what to update it to
   * @return {object} results from selected handler
   */
  self.update = function (keys,obs) {   
    return delegate.update(keys,obs);
  };
  
  self.updateGuts = function (keys,obs) {
    var memory = self.getMem();
    var r = memory.update (keys,obs,'key');
    return r.handleCode < 0 ? r : self.putBack (memory);
  }
  
  return self;
  
}