@vida-global/apps-tools 1.0.1

package/lib/apps/vidaApp.js

@@ -0,0 +1,345 @@
+const   _                           = require('lodash');
+const { logger }                    = require('@vida-global/core')
+const { IllegalAppInvocationError } = require('../errors/illegalAppInvocationError');
+
+
+class VidaApp {
+    functionHandler = null
+    hooksHandler = null
+    eventsHandler = null
+
+    constructor(
+      {
+          appId, appVersion, appManifest,
+          userContext,
+          providerManager,
+      }
+    ) {
+        this.appId = appId
+        this.appVersion = appVersion
+        this.manifest = appManifest
+
+        this.userContext = userContext
+
+        // this.manifest.installed = this.manifest.installed === undefined ? false : this.manifest.installed
+        // this.manifest.active = this.manifest.active === undefined ? false : this.manifest.active
+
+        this.isServer = true
+
+        this.providerManager = providerManager
+        this.providers = {}
+
+        this.functions = {}
+        this.hooks = {}
+        this.events = {}
+    }
+
+    id() {
+        return this.appId
+    }
+
+    version() {
+        return this.appVersion
+    }
+
+    context() {
+        return this.userContext
+    }
+
+    static async get(
+      appClass,
+      {
+          appId, appVersion, appManifest,
+          userContext,
+          providerManager,
+      },
+      {isServer = true}
+    ) {
+        const app = new appClass({
+            appId, appVersion, appManifest,
+            userContext,
+            providerManager,
+        })
+        await app._init({ isServer})
+        return app
+    }
+
+    async _init ({ isServer }) {
+        this.isServer = isServer
+
+        this.manifest.installed = await this.userContext.isAppInstalled(this.appId, this.appVersion)
+
+        await this.buildImplementationList()
+        await this.buildProviders()
+
+        if (!this.isServer) {
+            await this.checkActive()
+        }
+
+        if (this.isServer) {
+            if (this.functionHandler) {
+                this._functionHandler = new this.functionHandler(this)
+            }
+            if (this.hooksHandler) {
+                this._hooksHandler = new this.hooksHandler(this)
+            }
+            if (this.eventsHandler) {
+                this._eventsHandler = new this.eventsHandler(this)
+            }
+        }
+
+        try {
+            await this.initApp()
+        } catch (error) {
+            console.warn('Potential unhandled error in app init: ', error, this.appId, this.appVersion)
+        }
+    }
+
+    async initApp() {
+        // throw new Error('Not implemented')
+    }
+
+    isFunctionInApp(functionName) {
+        return !!this.functions[functionName]
+    }
+
+    isHookInApp(hookName) {
+        return !!this.hooks[hookName]
+    }
+
+    isEventInApp(eventName) {
+        return !!this.events[eventName]
+    }
+
+    async handleFunctionCall(functionName, functionArgs) {
+        if (!this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of handleFunctionCall method: this operation is not allowed in isServer mode.")
+        }
+        if (!(this.isFunctionInApp(functionName))) {
+            throw new Error(`Function "${functionName}" is not defined in the manifest.`);
+        }
+        if (!this._functionHandler) {
+            throw new Error(`No function handler defined in app ${this.appId}`)
+        }
+        logger.debug('Function call received', functionName, functionArgs)
+
+        const startTime = Date.now();
+        let result = await this._functionHandler[functionName](functionArgs);
+        result.functionName = functionName;
+        result.functionArgs = functionArgs;
+        result.responseTime = Date.now() - startTime;
+
+        return result
+    }
+
+    async handleHookCall(hookName, hookArgs) {
+        if (!this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of handleHookCall method: this operation is not allowed in isServer mode.")
+        }
+        if (!(this.isHookInApp(hookName))) {
+            throw new Error(`Hook "${hookName}" is not defined in the manifest.`);
+        }
+        if (!this._hooksHandler) {
+            throw new Error(`No hook handler defined in the app ${this.appId}`)
+        }
+        logger.debug('Hook call received', hookName, hookArgs)
+
+        const startTime = Date.now();
+        let result = await this._hooksHandler[hookName](hookArgs)
+        result.responseTime = Date.now() - startTime;
+
+        return result
+    }
+
+    async handleEvent(eventName, eventData) {
+        if (!this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of handleEvent method: this operation is not allowed in isServer mode.")
+        }
+        if (!(this.isEventInApp(eventName))) {
+            throw new Error(`Event "${eventName}" is not defined in the manifest.`);
+        }
+        if (!this._eventsHandler) {
+            throw new Error(`No event handler defined in the app ${this.appId}`)
+        }
+        logger.debug('Hook call received', eventName, eventData)
+
+        const startTime = Date.now();
+        let result = await this._eventsHandler[eventName](eventData)
+        result.responseTime = Date.now() - startTime;
+        return result
+    }
+
+    addProvider(providerType, providerName, providerInstance) {
+        if (!this.providers[providerType]) {
+            this.providers[providerType] = {}
+        }
+        this.providers[providerType][providerName] = providerInstance
+    }
+
+    async getProviderManifest(providerType, providerName) {
+        return await this.providers[providerType][providerName].getManifest()
+    }
+
+    async getCompositeManifest() {
+        logger.info(`Building composite manifest ${this.appId} ${this.appVersion}`)
+        await this.checkActive()
+        let compositeManifest = {...this.manifest}
+        const providerManifests = this.manifest.dependencies.providers
+        for (const [providerType, providers] of Object.entries(providerManifests)) {
+            for (const [providerName, vanillaProviderManifest] of Object.entries(providers)) {
+                const installedProviderManifest = await this.getProviderManifest(providerType, providerName)
+                compositeManifest.dependencies.providers[providerType][providerName] = _.merge(
+                    _.cloneDeep(vanillaProviderManifest), installedProviderManifest
+                )
+            }
+        }
+        return compositeManifest
+    }
+
+    async serialize(){
+        return await this.getCompositeManifest()
+    }
+
+    async buildProviders(update= false) {
+        const providerManifest = this.manifest.dependencies.providers
+        for (const [providerType, providers] of Object.entries(providerManifest)) {
+            for (const [providerName, providerConfig] of Object.entries(providers)) {
+                const provider = await this.providerManager.buildProvider(
+                  providerType, providerName, this.userContext, providerConfig,
+                  this.id(), this.version()
+                )
+                if (update) {
+                    provider.update(providerConfig)
+                }
+                this.addProvider(providerType, providerName, provider)
+            }
+        }
+    }
+
+      buildImplementationList() {
+        if (this.manifest) {
+          if (!this.manifest.implementations) {
+            this.manifest.implementations = {}
+          }
+
+          if (this.manifest.implementations.functions) {
+            for (const func of this.manifest.implementations.functions) {
+              this.functions[func.name] = func
+            }
+          }
+
+          if (this.manifest.implementations.hooks) {
+            for (const hook of this.manifest.implementations.hooks) {
+              this.hooks[hook.name] = hook
+            }
+          }
+
+          if (this.manifest.implementations.events) {
+            for (const event of this.manifest.implementations.events) {
+              this.events[event.name] = event
+            }
+          }
+        }
+    }
+
+    async update(manifest) {
+        return await this.install(manifest, true)
+    }
+
+    async reload(manifest) {
+        return await this.install(manifest, true)
+    }
+
+    async checkActive() {
+        this.manifest.active = true
+        for (const providers of Object.values(this.providers)) {
+            for (const providerInstance of Object.values(providers)) {
+                // Perform desired operations on each providerInstance
+                const isProviderConfigured = await providerInstance.isConfigured()
+                this.manifest.active = this.manifest.active && isProviderConfigured
+            }
+        }
+    }
+
+    async install(manifest, update = false) {
+        if (this.manifest.installed && !update) {
+            throw new Error('App is already installed')
+        }
+
+        this.manifest = manifest
+        this.manifest.installed = true
+        await this.buildImplementationList()
+        await this.buildProviders(true)
+        await this.checkActive()
+
+        if (!update) {
+            this.userContext.installApp(this.appId, this.appVersion)
+        }
+
+        return this.manifest
+    }
+
+    async getFunctions(onlyEnabled = false) {
+        let functions = (await this.getCompositeManifest()).implementations.functions;
+        if (onlyEnabled) {
+            const enabledFunctions = await this.userContext.getEnabledFunctions(this.appId, this.appVersion);
+            return functions.filter(func => {
+                return enabledFunctions.some(enabledFunc => enabledFunc === func.name);
+            })
+        } else {
+            return functions;
+        }
+    }
+
+    async getHooks() {
+        return this.manifest.implementations.hooks || []
+    }
+
+    async getAgentInstructions() {
+        const agent = this.userContext.get('agent')
+        const agentApps = agent.apps || []
+        const agentApp = _.find(agentApps, (app) => {
+            return app.appId === this.id() && app.version === this.version()
+        })
+        if (agentApp && agentApp.instructions) {
+            return agentApp.instructions
+        } else {
+            return this.manifest.description
+        }
+    }
+
+    isInstalled() {
+        if (this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of isInstalled method: this operation is not allowed in isServer mode.")
+        }
+        return this.manifest.installed
+    }
+
+    isActive() {
+        if (this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of isActive method: this operation is not allowed in isServer mode.")
+        }
+        return this.manifest.active
+    }
+
+    async uninstall() {
+        if (this.isServer) {
+            throw new IllegalAppInvocationError("Illegal invocation of uninstall method: this operation is not allowed in isServer mode.")
+        }
+
+        this.manifest.installed = false
+        this.manifest.active = false
+
+        // Uninstall all the user context and settings
+        await this.userContext.uninstallApp(this.appId, this.appVersion)
+
+        for (const providers of Object.values(this.providers)) {
+            for (const providerInstance of Object.values(providers)) {
+                await providerInstance.uninstall()
+            }
+        }
+    }
+}
+
+
+module.exports = { VidaApp }

package/lib/errors/illegalAppInvocationError.js

@@ -0,0 +1,8 @@
+class IllegalAppInvocationError extends Error {
+    constructor(message) {
+        super(message)
+    }
+}
+
+
+module.exports = { IllegalAppInvocationError };

package/lib/openApi/baseApiSpec.js

@@ -0,0 +1,10 @@
+module.exports = {
+    openapi: "3.0.0", // OpenAPI version
+    info: {
+        title: "VADER Endpoints",
+        description: "This documents the endpoints exposed by VADER and the configured applications.",
+        version: "1.0.0"
+    },
+    servers: [],
+    paths: {}
+}

package/lib/openApi/index.js

@@ -0,0 +1,150 @@
+const _           = require("lodash")
+const baseApiSpec = require('./baseApiSpec')
+
+function generateOpenApiSpecPaths(appId, version, functions, hooks) {
+    const paths        = {}
+    const contextSpecs = {
+        type: "object",
+        properties: {
+            user: {
+                type: "object",
+                description: "Agent user details",
+                example: {
+                    id: 100,
+                    username: "johndoe",
+                }
+            },
+            agent: {
+                type: "object",
+                description: "Agent configuration data",
+                example: {
+                    id: 200,
+                    name: "Cool Agent",
+                }
+            },
+            caller: {
+                type: "object",
+                description: "Caller data",
+                example: {
+                    id: 300,
+                    name: "Cool Caller",
+                    number: "+1234567890",
+                }
+            },
+            meta: {
+                type: "object",
+                description: "Convo meta",
+                example: {
+                    callId: "123asd456",
+                    convoUUID: "74c28825-aed9-45a6-8534-2177f2a66993 ",
+                }
+            },
+            manifest: {
+                type: "object",
+                description: "App manifest",
+                example: null
+            },
+        },
+        required: ["user", "agent", "caller"],
+    }
+    const responseSpecs = {
+        "200": {
+            description: "Successful response",
+            content: {
+                "application/json": {
+                    schema: {
+                        type: "object",
+                        additionalProperties: true,
+                    },
+                },
+            },
+        },
+        "400": {
+            description: "Bad request",
+        },
+        "500": {
+            description: "Server error",
+        },
+    }
+
+    functions.forEach((func) => {
+        const functionName = func.name
+        const endpoint = `/invoke/app/function/${appId}/${version}/${functionName}`
+
+        paths[endpoint] = {
+            post: {
+                summary: func.description,
+                tags: [`${appId}/${version}`],
+                operationId: `${functionName}Operation`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    userContext: contextSpecs,
+                                    functionArgs: func.parameters,
+                                },
+                                required: ['context', 'params'],
+                            },
+                        },
+                    },
+                },
+                responses: responseSpecs,
+            },
+        }
+    })
+
+    hooks.forEach((hook) => {
+        const hookName = hook.name
+        const endpoint = `/invoke/app/hook/${appId}/${version}/${hookName}`
+
+        paths[endpoint] = {
+            post: {
+                summary: hook.description,
+                tags: [`${appId}/${version}`],
+                operationId: `${hookName}Operation`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    userContext: contextSpecs,
+                                    parameters: hook.parameters,
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: responseSpecs,
+            }
+        }
+    })
+
+    return paths
+}
+
+
+async function generateOpenApiSpec(appManager) {
+    let paths = {}
+    for (const {id, version} of appManager.apps) {
+        const manifest = await appManager.fetchVanillaAppManifest(id, version)
+        const appPaths = generateOpenApiSpecPaths(id,
+                                                  version,
+                                                  manifest.implementations.functions || [],
+                                                  manifest.implementations.hooks || []);
+        paths = {...paths, ...appPaths}
+    }
+    const apiSpec = _.cloneDeep(baseApiSpec)
+    apiSpec.paths = paths
+    return apiSpec
+}
+
+
+module.exports = {
+  generateOpenApiSpec
+}
+

package/lib/providers/provider.js

@@ -0,0 +1,141 @@
+const _ = require('lodash');
+const { logger } = require('@vida-global/core');
+
+
+class BaseProviderConfigurator {
+    constructor(userContext, redisClient, type, name,
+                globalProviderConfig, appId, appVersion) {
+        this.userContext = userContext;
+        this.redis = redisClient;
+        this.type = type;
+        this.name = name;
+        this.globalConfig = globalProviderConfig;
+        this.appId = appId;
+        this.appVersion = appVersion;
+        this.hasBuiltRoutes = false;
+    }
+
+    async _initialize() {
+        await this.initialize();
+    }
+
+    async initialize() {
+        throw Error("Not implemented")
+    }
+
+    buildRoutes (expressApp) {
+        logger.info('No routes to be built for base configurator')
+    }
+}
+
+
+class BaseProvider {
+    type = null
+    name = 'sample-provider'
+    configurator = BaseProviderConfigurator
+
+    PROVIDER_GLOBAL_CONFIG_KEY () {
+        return `vader:providers:${this.type}:${this.name}:config`
+    }
+
+    constructor(
+      userContext, redisClient, vanillaConfig = null,
+      appId = null, appVersion = null,
+      isServer = false
+    ) {
+        this.userContext = userContext;
+        this.redis = redisClient;
+        this.isServer = isServer;
+        this.config = vanillaConfig || {};
+        this.appId = appId;
+        this.appVersion = appVersion;
+        this.globalConfig = {};
+    }
+
+    static async get(providerCls, {
+        userContext, redisClient, vanillaConfig,
+        appId, appVersion,
+        isServer = false
+    }) {
+        const provider = new providerCls(
+            userContext, redisClient, vanillaConfig,
+            appId, appVersion,
+            isServer
+        );
+        await provider._initialize();
+        return provider
+    }
+
+    async getConfigurator() {
+        const configurator = new this.configurator(
+          this.userContext, this.redis, this.type, this.name,
+          this.globalConfig,
+          this.appId, this.appVersion,
+        )
+        await configurator._initialize()
+        return configurator
+    }
+
+    async _initialize() {
+        if (!this.isServer) {
+            // Read global config and add it to config
+            let globalConfig = await this.redis.get(
+              this.PROVIDER_GLOBAL_CONFIG_KEY()
+            )
+            globalConfig = globalConfig ? JSON.parse(globalConfig) : {}
+            this.globalConfig = globalConfig
+
+            if (this.userContext) {
+                let userProviderConfig = await this.userContext.getProviderConfig(
+                  this.type, this.name, this.appId, this.appVersion
+                ) || {}
+                this.config = _.merge(_.cloneDeep(this.config), userProviderConfig)
+            }
+        } else {
+            if (this.userContext) {
+                let userProviderConfig = await this.userContext.getProviderConfig(
+                  this.type, this.name, this.appId, this.appVersion
+                ) || {}
+                this.config = _.merge(_.cloneDeep(this.config), userProviderConfig)
+            }
+        }
+        await this.initialize();
+    }
+
+    async getProperty (name) {
+        return this.config.parameters.properties[name].value;
+    }
+
+    async saveConfig(config) {
+        await this.userContext.setProviderConfig(
+          this.type, this.name, config,
+          this.appId, this.appVersion
+        )
+    }
+
+    async update(config) {
+        throw Error("Not implemented")
+    }
+
+    async isConfigured() {
+        throw Error("Not implemented")
+    }
+
+    async getManifest() {
+        throw Error("Not implemented")
+    }
+
+    async initialize() {
+        throw new Error("Not implemented");
+    }
+
+    async uninstall () {
+        throw new Error("Not implemented");
+    }
+}
+
+
+module.exports = {
+    BaseProviderConfigurator,
+    BaseProvider
+}