@vida-global/apps-tools 1.0.1

package/lib/providers/providerManager.js

@@ -0,0 +1,73 @@
+const { logger } = require('@vida-global/core')
+
+
+class ProviderManager {
+    #isServer;
+    #redisClient;
+
+
+    constructor(redisClient, isServer) {
+        this.#isServer    = isServer;
+        this.#redisClient = redisClient;
+    }
+
+
+    get providersDirectory() {
+        return `${__dirname}/providers`;
+    }
+
+
+    providerPath(providerType, providerName) {
+        return `${this.providersDirectory}/${providerType}/${providerName}/index.js`;
+    }
+
+
+    getProvider(providerType, providerName) {
+        const providerPath = this.providerPath(providerType, providerName)
+        return require(providerPath);
+    }
+
+
+    async buildProvider(providerType, providerName, userContext, vanillaConfig, appId, appVersion) {
+        const providerCls  = this.getProvider(providerType, providerName);
+        if (!providerCls) {
+            throw new Error(`Provider ${providerName} not found`)
+        }
+        logger.info(`VADER: Building provider ${providerType}:${providerName}`)
+        return await providerCls.get(
+            providerCls, {
+                userContext,
+                redisClient: this.#redisClient,
+                vanillaConfig: vanillaConfig,
+                appId, appVersion,
+                isServer: this.#isServer,
+            }
+        )
+    }
+
+
+    async buildRoutes(server, providerList) {
+        logger.info('VADER: Building provider configurator routes')
+        for (const providerTypeName of providerList) {
+            const providerType = providerTypeName.split(':')[0]
+            const providerName = providerTypeName.split(':')[1]
+            const providerInstance = await this.buildProvider(providerType,
+                                                              providerName,
+                                                              null,
+                                                              null,
+                                                              null,
+                                                              null);
+            if (providerInstance.configurator) {
+                logger.info(`VADER: Building routes for provider ${providerType}:${providerName}`)
+                const configuratorInstance = await providerInstance.getConfigurator()
+                configuratorInstance.buildRoutes(server)
+            }
+        }
+    }
+}
+
+
+module.exports = {
+    ProviderManager
+}
+

package/lib/providers/providers/auth/generic/index.js

@@ -0,0 +1,60 @@
+const {google} = require('googleapis');
+const {logger} = require('@vida-global/core');
+const {BaseProvider, BaseProviderConfigurator} = require('../../../provider');
+
+
+class GenericAuthConfigurator extends BaseProviderConfigurator {
+    async initialize() {
+        logger.info('Generic Auth Configurator Initialized')
+    }
+}
+
+class GenericAuthProvider extends BaseProvider {
+    type = 'auth'
+    name = 'generic'
+    configurator = GenericAuthConfigurator
+
+    async initialize () {
+        logger.info('Generic Auth Provider Initialized')
+    }
+
+    async uninstall () {
+        logger.info('Generic Auth Provider Uninstalled')
+        await this.userContext.deleteProviderConfig(
+          this.type, this.name, this.appId, this.appVersion
+        )
+    }
+
+    async update (config) {
+        logger.info('Generic Auth Provider Updated')
+        await this.userContext.setProviderConfig(
+          this.type, this.name, config,
+          this.appId, this.appVersion
+        )
+        this.config = config;
+    }
+
+    async getManifest () {
+        return this.config
+    }
+
+    async isConfigured () {
+        if (this.config && this.config.parameters) {
+            const {properties, required} = this.config.parameters;
+            if (required && Array.isArray(required)) {
+                for (const field of required) {
+                    const property = properties[field];
+                    if (!property || !property.value ||
+                      (property.type === 'string' && property.value.trim() === '') ||
+                      (typeof property.value !== property.type)) {
+                        console.log(`Missing required field: ${field}`, property)
+                        return false; // Mark as not configured if a required field is missing, has no value, or type mismatch
+                    }
+                }
+            }
+        }
+        return true; // All required fields exist and are properly configured
+    }
+}
+
+module.exports = GenericAuthProvider;

package/lib/providers/providers/auth/google/index.js

@@ -0,0 +1,251 @@
+const axios = require('axios');
+const { URL } = require('url');
+const { BaseProvider, BaseProviderConfigurator } = require('../../../provider');
+const { logger } = require('@vida-global/core');
+const _ = require('lodash');
+
+
+const oAuthConfig = {
+    scopes: [
+        'https://www.googleapis.com/auth/calendar',
+        'https://www.googleapis.com/auth/calendar.events',
+        'https://www.googleapis.com/auth/userinfo.profile'
+    ],
+    initiateOAuthUrl: '/vader/oauth/google/initiate',
+    callbackPath: '/vader/oauth/google/callback',
+    authorizationEndpoint: 'https://accounts.google.com/o/oauth2/v2/auth',
+    tokenEndpoint: 'https://oauth2.googleapis.com/token'
+}
+
+
+class GoogleOAuthConfigurator extends BaseProviderConfigurator {
+    async storeToken(user, tokenResponse) {
+        let tokenInfo = {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+        };
+
+        await this.redis.set(this.TOKEN_KEY(user), JSON.stringify(tokenInfo));
+    }
+
+    getAuthorizationUrl(redirectUri, state) {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            response_type: 'code',
+            redirect_uri: redirectUri,
+            scope: oAuthConfig.scopes.join(' '),
+            access_type: 'offline',
+            state: state
+        });
+
+        return `${oAuthConfig.authorizationEndpoint}?${params.toString()}`;
+    }
+
+    buildRoutes(app) {
+        app.get(oAuthConfig.initiateOAuthUrl, async (req, res) => {
+            const {redirectUri, userId} = req.query;
+
+            if (!redirectUri || !userId) {
+                return res.status(400).send('Missing required parameters: redirectUri and userId');
+            }
+
+            const stateData = {
+                redirectUri,
+                userId
+            };
+
+            const authUrl = this.getAuthorizationUrl(redirectUri, Buffer.from(JSON.stringify(stateData)).toString('base64'));
+            res.redirect(authUrl);
+        });
+
+        app.get(oAuthConfig.callbackPath, async (req, res) => {
+            let redirectUri = null;
+            try {
+                redirectUri = await this.handleOAuthCallback(req);
+                res.redirect(redirectUri);
+            } catch (error) {
+                console.error('OAuth callback error:', error);
+                res.status(500).send('Authentication failed. Please try again.');
+            }
+        });
+    }
+
+    async handleOAuthCallback(req) {
+        if (req.query.error) {
+            throw new Error(`OAuth error: ${req.query.error}`);
+        }
+
+        const {code, state} = req.query;
+        if (!code) {
+            throw new Error('No authorization code received');
+        }
+        if (!state) {
+            throw new Error('No state parameter received');
+        }
+
+        const sessionData = JSON.parse(Buffer.from(state, 'base64').toString());
+        let {redirectUri, userId} = sessionData;
+        if (!redirectUri || !userId) {
+            throw new Error('Invalid state parameter');
+        }
+        redirectUri = decodeURIComponent(redirectUri);
+        let user = {id: userId};
+        let success = true;
+
+        try {
+            const response = await axios.post(
+              oAuthConfig.tokenEndpoint,
+              new URLSearchParams({
+                  client_id: this.config.clientId,
+                  client_secret: this.config.clientSecret,
+                  code: code,
+                  redirect_uri: redirectUri,
+                  grant_type: 'authorization_code'
+              }).toString(),
+              {
+                  headers: {
+                      'Content-Type': 'application/x-www-form-urlencoded'
+                  }
+              }
+            );
+            await this.storeToken(user, response.data);
+        } catch (error) {
+            console.error('Error exchanging code for token:', error);
+            success = false;
+        }
+
+        const finalUrl = new URL(redirectUri);
+        finalUrl.searchParams.append('success', success ? 'true' : 'false');
+        finalUrl.searchParams.append('userId', user.id);
+        return finalUrl.toString();
+    }
+}
+
+class GoogleAuthProvider extends BaseProvider {
+    type = 'auth';
+    name = 'oauth2';
+    configurator = GoogleOAuthConfigurator;
+
+    TOKEN_KEY(user) {
+        return `vader:oauth:google:${user.id}:token`;
+    }
+
+    async initialize() {
+        if (!this.isServer && this.user) {
+            const tokenData = await this.redis.get(this.TOKEN_KEY(this.user));
+            if (tokenData) {
+                this.tokenInfo = JSON.parse(tokenData);
+            }
+            if (this.isTokenExpired()) {
+                await this.refreshToken();
+            }
+        }
+        this.config = {
+            ...this.config,
+            ...oAuthConfig
+        }
+        logger.info('Google OAuth Provider Initialized')
+    }
+
+    async uninstall() {
+        await this.redis.del(this.TOKEN_KEY(this.user));
+    }
+
+    async isConfigured() {
+        if (!this.config.clientId || !this.config.clientSecret) {
+            return false;
+        }
+
+        if (!this.tokenInfo) {
+            return false;
+        }
+
+        if (this.isTokenExpired() && !(await this.refreshToken())) {
+            logger.warn('Google OAuth Provider: Token expired and failed to refresh');
+            return false;
+        }
+
+        return true;
+    }
+
+    async getManifest() {
+        if (this.isServer) {
+            return {
+                ...oAuthConfig
+            }
+        } else {
+            return {
+                ...oAuthConfig,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        accessToken: {
+                            type: "string",
+                            description: "Access Token for Google API.",
+                            value: await this.getAccessToken(),
+                        }
+                    },
+                    required: ["accessToken"],
+                }
+            }
+        }
+    }
+
+    isTokenExpired() {
+        if (!this.tokenInfo || !this.tokenInfo.expiresAt) {
+            return true;
+        }
+        // Add a 5-minute buffer before expiration
+        return Date.now() >= (this.tokenInfo.expiresAt - 300000);
+    }
+
+    async getAccessToken() {
+        if (this.isTokenExpired()) {
+            await this.refreshToken();
+        }
+        return this.tokenInfo?.accessToken;
+    }
+
+    async refreshToken() {
+        if (!this.tokenInfo?.refreshToken) {
+            return false;
+        }
+
+        try {
+            const response = await axios.post(
+              oAuthConfig.tokenEndpoint,
+              new URLSearchParams({
+                  client_id: this.config.clientId,
+                  client_secret: this.config.clientSecret,
+                  refresh_token: this.tokenInfo.refreshToken,
+                  grant_type: 'refresh_token'
+              }).toString(),
+              {
+                  headers: {
+                      'Content-Type': 'application/x-www-form-urlencoded'
+                  }
+              }
+            );
+
+            await this.storeToken(response.data);
+            return true;
+        } catch (error) {
+            logger.error('Error refreshing token:', error);
+            return false;
+        }
+    }
+
+    async storeToken(tokenResponse) {
+        let tokenInfo = {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token || this.tokenInfo?.refreshToken,
+            expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+        };
+
+        this.tokenInfo = tokenInfo;
+        await this.redis.set(this.TOKEN_KEY(this.user), JSON.stringify(tokenInfo));
+    }
+}
+
+module.exports = GoogleAuthProvider;

package/lib/providers/providers/auth/hubspot/index.js

@@ -0,0 +1,313 @@
+const axios = require('axios');
+const { URL } = require('url');
+const { logger } = require('@vida-global/core');
+const { BaseProvider, BaseProviderConfigurator } = require('../../../provider');
+const { VaderUserContext } = require('../../../../userContext');
+const _ = require('lodash');
+
+
+const oAuthConfig = {
+  initiateOAuthUrl: '/vader/oauth/hubspot/initiate',
+  callbackPath: '/vader/oauth/hubspot/callback',
+  authorizationEndpoint: 'https://app.hubspot.com/oauth/authorize',
+  tokenEndpoint: 'https://api.hubapi.com/oauth/v1/token',
+  scopes: [
+    'crm.objects.contacts.read',
+    'crm.objects.contacts.write',
+    'crm.objects.companies.read',
+    'forms',
+    'oauth',
+    'tickets',
+  ]
+};
+
+
+class HubspotOAuthConfigurator extends BaseProviderConfigurator {
+  async initialize() {
+    logger.info('HubSpot OAuth Configurator Initialized')
+  }
+
+  async storeToken(user, tokenResponse, appId, appVersion) {
+    let tokenData = {
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+    };
+    let ctx = this.userContext
+    if (!ctx) {
+      // Build a new user context using our own
+      ctx = new VaderUserContext(this)
+      await ctx.load({ user })
+    }
+    let providerConfig = await ctx.getProviderConfig(
+      this.type, this.name, appId, appVersion
+    )
+    providerConfig = _.merge(_.cloneDeep(providerConfig), {
+      tokenData: tokenData,
+    })
+    await ctx.setProviderConfig(
+      this.type, this.name, providerConfig,
+      appId, appVersion
+    );
+  }
+
+  getAuthorizationUrl(redirectUri, state) {
+    const params = new URLSearchParams({
+      client_id: this.globalConfig.clientId,
+      redirect_uri: redirectUri,
+      scope: oAuthConfig.scopes.join(' '),
+      state: state
+    });
+    return `${oAuthConfig.authorizationEndpoint}?${params.toString()}`;
+  }
+
+  buildRoutes(app) {
+    if (this.hasBuiltRoutes) {
+      logger.warn('OAuth routes already built');
+      return
+    }
+
+    app.get(oAuthConfig.initiateOAuthUrl, async (req, res) => {
+      let {redirectUri, finalUri, userId, appId, appVersion} = req.query;
+
+      // TODO: Remove this after passing from frontend
+      if (!appId) {
+        appId = 'hubspot';
+      }
+      if (!appVersion) {
+        appVersion = 'v1';
+      }
+
+      if (!redirectUri || !finalUri || !userId || !appId || !appVersion) {
+        return res.status(400).send(
+          'Missing one or more required parameters: redirectUri, finalUri, userId, appId, appVersion'
+        );
+      }
+
+      const stateData = {
+        redirectUri,
+        finalUri,
+        userId,
+        appId,
+        appVersion,
+      };
+
+      const authUrl = this.getAuthorizationUrl(
+          redirectUri, Buffer.from(JSON.stringify(stateData)).toString('base64')
+      );
+      res.redirect(authUrl);
+    });
+
+    app.get(oAuthConfig.callbackPath, async (req, res) => {
+      let redirectUri = null;
+      try {
+        redirectUri = await this.handleOAuthCallback(req);
+        res.redirect(redirectUri);
+      } catch (error) {
+        logger.error('OAuth callback error:', error);
+        res.status(500).send('Authentication failed. Please try again.');
+      }
+    });
+    this.hasBuiltRoutes = true;
+  }
+
+  async handleOAuthCallback(req) {
+    if (req.query.error) {
+      throw new Error(`OAuth error: ${req.query.error}`);
+    }
+
+    const {code, state} = req.query;
+    if (!code) {
+      throw new Error('No authorization code received');
+    }
+    if (!state) {
+      throw new Error('No state parameter received');
+    }
+
+    const sessionData = JSON.parse(Buffer.from(state, 'base64').toString());
+    let {redirectUri, finalUri, userId, appId, appVersion} = sessionData;
+
+    // TODO: Remove this after passing from frontend
+    if (!appId) {
+      appId = 'hubspot';
+    }
+    if (!appVersion) {
+      appVersion = 'v1';
+    }
+
+    if (!redirectUri || !finalUri || !userId || !appId || !appVersion) {
+      throw new Error('Invalid state parameters');
+    }
+    redirectUri = decodeURIComponent(redirectUri);
+    let user = {id: userId};
+    let success = true;
+
+    try {
+      const response = await axios.post(
+        oAuthConfig.tokenEndpoint,
+        new URLSearchParams({
+          grant_type: 'authorization_code',
+          client_id: this.globalConfig.clientId,
+          client_secret: this.globalConfig.clientSecret,
+          redirect_uri: redirectUri,
+          code: code
+        }).toString(),
+        {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        }
+      );
+      await this.storeToken(user, response.data, appId, appVersion);
+    } catch (error) {
+      logger.error('Error exchanging code for token:');
+      console.error(error)
+      success = false;
+    }
+
+    const finalUrl = new URL(finalUri);
+    finalUrl.searchParams.set('hubspotOAuthSuccess', success ? 'true' : 'false');
+    finalUrl.searchParams.set('userId', user.id);
+    return finalUrl.toString();
+  }
+}
+
+
+class HubspotAuthProvider extends BaseProvider {
+  type = 'auth';
+  name = 'hubspot';
+  configurator = HubspotOAuthConfigurator;
+
+  async initialize() {
+    if (!this.isServer && this.userContext) {
+      const providerConfig = await this.userContext.getProviderConfig(
+        this.type, this.name, this.appId, this.appVersion
+      );
+
+      this.config = {
+        ...this.config,
+        ...providerConfig
+      }
+
+      if (this.isTokenExpired()) {
+        await this.refreshToken();
+      }
+      this.config.parameters = {
+        type: "object",
+        properties: {
+          accessToken: {
+            type: "string",
+            description: "Access Token to access the Hubspot API.",
+            value: await this.getAccessToken(),
+          }
+        },
+        required: ["accessToken"],
+      }
+    }
+    logger.info('HubSpot OAuth Provider Initialized', this.config)
+  }
+
+  async uninstall() {
+    logger.info('Uninstalling HubSpot OAuth Provider')
+    await this.userContext.deleteProviderConfig(
+      this.type, this.name, this.appId, this.appVersion
+    );
+  }
+
+  async update(config) {
+    logger.info('Updating HubSpot OAuth Provider')
+  }
+
+  async isConfigured() {
+    if (!this.globalConfig.clientId || !this.globalConfig.clientSecret) {
+      return false;
+    }
+
+    if (!this.config.tokenData) {
+      return false;
+    }
+
+    if (this.isTokenExpired() && !(await this.refreshToken())) {
+      logger.warn('HubSpot OAuth Provider: Token expired and failed to refresh');
+      return false;
+    }
+
+    return true;
+  }
+
+  async getManifest() {
+    if (this.isServer) {
+      return {
+        ...oAuthConfig
+      }
+    } else {
+      let manifest = {
+        ...oAuthConfig,
+        ...this.config,
+        connected: !!await this.getAccessToken()
+      }
+      return _.omit(manifest, ['clientId', 'clientSecret', 'appId']);
+    }
+  }
+
+  isTokenExpired() {
+    if (!this.config.tokenData || !this.config.tokenData.expiresAt) {
+      return true;
+    }
+    // Add a 5-minute buffer before expiration
+    return Date.now() >= (this.config.tokenData.expiresAt - 300000);
+  }
+
+  async getAccessToken() {
+    if (this.isTokenExpired()) {
+      await this.refreshToken();
+    }
+    return this.config.tokenData?.accessToken;
+  }
+
+  async refreshToken() {
+    if (!this.config.tokenData?.refreshToken) {
+      return false;
+    }
+
+    try {
+      const response = await axios.post(
+        oAuthConfig.tokenEndpoint,
+        new URLSearchParams({
+          grant_type: 'refresh_token',
+          client_id: this.globalConfig.clientId,
+          client_secret: this.globalConfig.clientSecret,
+          refresh_token: this.config.tokenData.refreshToken
+        }).toString(),
+        {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        }
+      );
+
+      await this.storeToken(response.data);
+      return true;
+    } catch (error) {
+      logger.error('Error refreshing token:', error);
+      return false;
+    }
+  }
+
+  async storeToken(tokenResponse) {
+    let tokenData = {
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token || this.config.tokenData?.refreshToken,
+      expiresAt: Date.now() + (tokenResponse.expires_in * 1000)
+    };
+    this.config = _.merge(_.cloneDeep(this.config), {
+      tokenData: tokenData,
+    })
+    await this.userContext.setProviderConfig(
+      this.type, this.name, this.config,
+      this.appId, this.appVersion
+    );
+  }
+}
+
+module.exports = HubspotAuthProvider;