oidc-lib/src/wallet_sw/hub_app_provider.js

A library for creating OIDC Service Providers

"use strict"
Object.defineProperty(exports, "__esModule", { value: true });

var indexed_db_module = require('../claimer_sts/dbs/indexed_db');
var moduleName = 'hub_app_provider';

module.exports = {
    hub_provider: hub_provider,
    decryptDbRecord: decryptDbRecord,
    hubExport: hubExport,
    deviceManager: deviceManager
}

function hub_provider(){
    var pk;
    const HttpStatusCodes = { NOTFOUND: 404 };
    var indexed_db;
    var METADATACOLLECTIONNAME;
    var hubConfig;

    Object.defineProperty(this, "initialize", {
        value: function(pkInput, contentModuleName, provider){
            return new Promise((resolve, reject) => {
                var hubDbInfo;
                var hubDbContents = {};
                var schemas = [];
                var hubInfo;

                pk = pkInput;
                hubConfig = pk.util.config.hub;
                indexed_db = new indexed_db_module.indexed_db_provider();
                 indexed_db.initialize(pkInput, contentModuleName, indexed_db)
                .then(dbInfo => {
                    if (dbInfo){
                        hubDbInfo = {
                            contentModuleName: dbInfo.contentModuleName,
                            collections: dbInfo.collections,
                            databaseDefinition: dbInfo.databaseDefinition,
                            databaseName: dbInfo.databaseName,
                            databaseUrl: dbInfo.databaseUrl,
                            schemaVersion: dbInfo.schemaVersion,
                            provider: this,
                            dbInfo: dbInfo
                        };

                        resolve(hubDbInfo);
                    }
                }, function(err){
                    pk.util.log_detail('ERROR initializing database', err);
                })
            });
        }
    })

/*
    Object.defineProperty(this, "createOrUpdateDocument", {
        value: function (hubDbInfo, collectionName, objectToWrite) {
            return new Promise((resolve, reject) => {
                updateHub(hubDbInfo, collectionName, objectToWrite)
                .then(function(writeResult){
                    resolve(objectToWrite);
                }, function(err){
                    reject(err);
                })
            });
        }
    });
*/

    Object.defineProperty(this, "createOrUpdateDocument", {
        value: function (hubDbInfo, collectionName, objectToWrite, options) {
            return new Promise((resolve, reject) => {
                var record;
                var didMeta;
                var updateISO;
                var operation;
                var hub_payload;
                var collectionInfo;

                encryptDbRecord(hubDbInfo, collectionName, objectToWrite, options)
                .then(result => {
                    if (result){
                        record = result;
                        collectionInfo = hubDbInfo.collections[collectionName];

                        var date = new Date();
                        updateISO = date.toISOString();
                        var time = Date.parse(updateISO);
                        if (collectionInfo.highWater < time){
                            collectionInfo.highWater = time;
                        }

                        didMeta = record.didMeta;
                        if (didMeta === undefined){
                            didMeta = {};
                        }

                        if (didMeta.created_at === undefined){
                            didMeta.created_at = updateISO;
                        }
                        record.didMeta = didMeta;
                        return hubDbInfo.dbInfo.provider.createOrUpdateDocument(hubDbInfo.dbInfo, collectionName, record);
                    }
                }, err => {
                    reject(err);
                })
                .then(result => {
                    if (result){
                        objectToWrite.didMeta = result.didMeta;
                        resolve(objectToWrite);
                    }
                }, err => {
                    reject(err);
                })
            });
        }
    });

    Object.defineProperty(this, "getDocument", {
        value: function (hubDbInfo, collectionName, local_id) {
            return new Promise((resolve, reject) => {
                indexed_db.getDocument(hubDbInfo.dbInfo, collectionName, local_id)
                .then( record => {
                    return decryptDbRecord(hubDbInfo, collectionName, record);
                }, err => {
                    reject(err);
                })
                .then( plaintext => {
                    resolve(plaintext);
                }, err => {
                    reject(err);
                })
            });
        }
    });

    Object.defineProperty(this, "queryCollection", {
        value: function (hubDbInfo, collectionName, queryDictionaryOrString, indexName) {
            return new Promise((resolve, reject) => {
                var encryptedRecords;
                indexed_db.queryCollection(hubDbInfo.dbInfo, collectionName, queryDictionaryOrString, indexName)
                .then(function(queryResult){
                    encryptedRecords = queryResult;
                    var plaintextPromises = [];
                    for (var i=0; i < queryResult.length; i++){
                        var record = queryResult[i];
                        plaintextPromises.push(decryptDbRecord(hubDbInfo, collectionName, record));
                    }

                    return Promise.all(plaintextPromises);
                }, function(err){
                    reject(err);
                })
                .then(plaintextRecords => {
                    if (plaintextRecords){
                        resolve(plaintextRecords);
                    }
                }, err => {
                    reject(err);
                })
            });
        }
    });


    Object.defineProperty(this, "deleteDocument", {
        value: function(hubDbInfo, collectionName, local_id){
            return indexed_db.deleteDocument(hubDbInfo.dbInfo, collectionName, local_id);
        }
    });

    function updateHub(dbInfo, collectionName, objectToWrite, options){
        return new Promise((resolve, reject) => {
            var payload = {
                action: 'updateHub',
                contentModuleName: dbInfo.contentModuleName,
                collectionName: collectionName,
                objectToWrite: pk.base64url.encode(JSON.stringify(objectToWrite)),
                options: options
            }
            pk.util.send_message_to_serviceWorker(payload)
            .then( result => {
                resolve(result);
            }, err => {
                reject(err);
            })
        })
    }
}

function decryptDbRecord(dbInfo, collectionName, encryptedRecord){
    return new Promise((resolve, reject) => {
        var payload = {
            action: 'decryptDbRecord',
            contentModuleName: dbInfo.contentModuleName,
            collectionName: collectionName,
            encryptedRecord: encryptedRecord
        }
        pk.util.send_message_to_serviceWorker(payload)
        .then( result => {
            resolve(result);
        }, err => {
            reject(err);
        })
    })
}

function encryptDbRecord(dbInfo, collectionName, objectToWrite, options){
    return new Promise((resolve, reject) => {
        var payload = {
            action: 'encryptDbRecord',
            contentModuleName: dbInfo.contentModuleName,
            collectionName: collectionName,
            objectToWrite: objectToWrite,
            options: options
        }
        pk.util.send_message_to_serviceWorker(payload)
        .then( result => {
            resolve(result);
        }, err => {
            reject(err);
        })
    })
}


function hubExport(){
    return new Promise((resolve, reject) => {
        var payload = {
            action: 'hubExport'
        }
        pk.util.send_message_to_serviceWorker(payload)
        .then( result => {
            resolve(result);
        }, err => {
            reject(err);
        })
    })
}

function deviceManager(){
    return new deviceManagerFactory();
}

function deviceManagerFactory(){
    Object.defineProperty(this, "addDevice", {
        value: function(role) {
            return new Promise((resolve, reject) => {
                var payload = {
                    action: 'deviceManagerFactory_addDevice',
                    role: role
                }
                pk.util.send_message_to_serviceWorker(payload)
                .then( result => {
                    resolve(result);
                }, err => {
                    reject(err);
                })
            })
        }
    })

    Object.defineProperty(this, "executeDeviceAddition", {
        value: function(rendezvousValue) {
            return new Promise((resolve, reject) => {
                var payload = {
                    action: 'deviceManagerFactory_executeDeviceAddition',
                    rendezvousValue: rendezvousValue
                }
                pk.util.send_message_to_serviceWorker(payload)
                .then( result => {
                    resolve(result);
                }, err => {
                    reject(err);
                })
            })
        }
    })

    Object.defineProperty(this, "conveyFlockMembershipCipher", {
        value: function(rendezvousId, flockMembershipCipher) {
            return new Promise((resolve, reject) => {
                var payload = {
                    action: 'deviceManagerFactory_conveyFlockMembershipCipher',
                    rendezvousId: rendezvousId,
                    flockMembershipCipher: flockMembershipCipher
                }
                pk.util.send_message_to_serviceWorker(payload)
                .then( result => {
                    window.location.reload();
                    resolve(result);
                }, err => {
                    reject(err);
                })
            })
        }
    })

    Object.defineProperty(this, "exportFlockMembershipCipher", {
        value: function() {
            return new Promise((resolve, reject) => {
                var payload = {
                    action: 'deviceManagerFactory_exportFlockMembershipCipher',
                }
                pk.util.send_message_to_serviceWorker(payload)
                .then( result => {
                    resolve(result);
                }, err => {
                    reject(err);
                })
            })
        }
    })
}