extension.js

'use strict';
const validator = require('validator');
const { FdkInvalidExtensionConfig } = require("./error_code");
const urljoin = require('url-join');
const { PlatformClient, PartnerClient } = require("@gofynd/fdk-client-javascript");
const { WebhookRegistry } = require('./webhook');
const logger = require('./logger');
const { fdkAxios } = require('@gofynd/fdk-client-javascript/sdk/common/AxiosHelper');
const { version } = require('./../package.json');
const { RetryManger } = require("./retry_manager")

class Extension {
    constructor() {
        this.api_key = null;
        this.api_secret = null;
        this.storage = null;
        this.base_url = null;
        this.callbacks = null;
        this.access_mode = null;
        this.cluster = "https://api.fynd.com";
        this.webhookRegistry = null;
        this._isInitialized = false;
        this._retryManager = new RetryManger();
        this.configData = null;
    }

    async initialize(data) {

        if (this._isInitialized) {
            return;
        }

        this._isInitialized = false;
        this.configData = data;

        this.storage = data.storage;

        if (!data.api_key) {
            throw new FdkInvalidExtensionConfig("Invalid api_key");
        }
        this.api_key = data.api_key;

        if (!data.api_secret) {
            throw new FdkInvalidExtensionConfig("Invalid api_secret");
        }
        this.api_secret = data.api_secret;

        if (!data.callbacks || (data.callbacks && (!data.callbacks.auth || !data.callbacks.uninstall))) {
            throw new FdkInvalidExtensionConfig("Missing some of callbacks. Please add all `auth` and `uninstall` callbacks.");
        }

        this.callbacks = data.callbacks;
        this.access_mode = data.access_mode || "offline";

        if (data.cluster) {
            if (!validator.isURL(data.cluster)) {
                throw new FdkInvalidExtensionConfig("Invalid cluster value. Invalid value: " + data.cluster);
            }
            this.cluster = data.cluster;
        }
        else
            data.cluster = this.cluster;
        this.webhookRegistry = new WebhookRegistry(this._retryManager);

        await this.getExtensionDetails();

        if (data.base_url && !validator.isURL(data.base_url)) {
            throw new FdkInvalidExtensionConfig("Invalid base_url value. Invalid value: " + data.base_url);
        }
        else if (!data.base_url) {
            data.base_url = this.extensionData.base_url;
        }

        if (data.base_url && data.base_url !== this.extensionData.base_url) {
            await this.updateExtensionBaseUrl(data.base_url);
        }

        this.base_url = data.base_url;

        if (data.scopes) {
            logger.warn(`'scopes' in setupFdk config is deprecated and will be ignored. Scopes from Partners panel will be used instead.`);
        }
        this.scopes = this.extensionData.scope;

        logger.debug(`Extension initialized`);

        if (data.webhook_config && Object.keys(data.webhook_config)) {
            await this.webhookRegistry.initialize(data.webhook_config, data);
        }

        this._isInitialized = true;
    }

    get isInitialized() {
        return this._isInitialized;
    }

    getAuthCallback() {
        return urljoin(this.base_url, "/fp/auth");
    }

    isOnlineAccessMode() {
        return this.access_mode === 'online';
    }

    async getPlatformConfig(companyId) {
        if (!this._isInitialized){
            await this.initialize(this.configData);
        }
        
        // Create client without session for OAuth operations only
        let platformClient = new PlatformClient({
            companyId: parseInt(companyId),
            domain: this.cluster,
            apiKey: this.api_key,
            apiSecret: this.api_secret,
            useAutoRenewTimer: false,
            logLevel: this.configData.debug === true? "debug": null
        });
        
        return platformClient.config; // Return just the config
    }

    async getPlatformClient(companyId, session) {
        if (!this._isInitialized){
            await this.initialize(this.configData);
        }
        const SessionStorage = require('./session/session_storage');
        let platformClient = new PlatformClient({
            companyId: parseInt(companyId),
            domain: this.cluster,
            apiKey: this.api_key,
            apiSecret: this.api_secret,
            useAutoRenewTimer: false,
            logLevel: this.configData.debug === true? "debug": null
        });

        platformClient.config.oauthClient.setToken(session);
        platformClient.config.oauthClient.token_expires_at = session.access_token_validity;

        if (!session.access_token_validity || session.refresh_token) {
            let ac_nr_expired = !session.access_token_validity? true: ((session.access_token_validity - new Date().getTime()) / 1000) <= 120;
            if (ac_nr_expired) {
                logger.debug(`Renewing access token for company ${companyId}`);
                const renewTokenRes = await platformClient.config.oauthClient.renewAccessToken(session.access_mode === 'offline');
                renewTokenRes.access_token_validity = platformClient.config.oauthClient.token_expires_at;
                session.updateToken(renewTokenRes);
                await SessionStorage.saveSession(session);
                logger.debug(`Access token renewed for company ${companyId}`);
            }
        }
        platformClient.setExtraHeaders({
            'x-ext-lib-version': `js/${version}`
        })
        return platformClient;
    }

    getPartnerConfig(organizationId) {
        if (!this._isInitialized) {
            throw new FdkInvalidExtensionConfig("Extension not initialized due to invalid data");
        }
    
        // Create client without session for OAuth operations only  
        let partnerClient = new PartnerClient({
            organizationId: organizationId,
            domain: this.cluster,
            apiKey: this.api_key,
            apiSecret: this.api_secret,
            useAutoRenewTimer: false,
            logLevel: this.configData.debug === true? "debug": null
        });
        
        return partnerClient.config; // Return just the config
    }

    async getPartnerClient(organizationId, session) {
        if (!this._isInitialized) {
            throw new FdkInvalidExtensionConfig('Extension not initialized due to invalid data')
        }
        const SessionStorage = require('./session/session_storage');

        let partnerClient = new PartnerClient({
            organizationId: organizationId,
            domain: this.cluster,
            apiKey: this.api_key,
            apiSecret: this.api_secret,
            useAutoRenewTimer: false,
            logLevel: this.configData.debug === true? "debug": null
        });

        partnerClient.config.oauthClient.setToken(session);
        partnerClient.config.oauthClient.token_expires_at = session.access_token_validity;

        if (!session.access_token_validity || session.refresh_token) {
            let ac_nr_expired = ((session.access_token_validity - new Date().getTime()) / 1000) <= 120;
            if (ac_nr_expired) {
                logger.debug(`Renewing access token for organization ${organizationId}`);
                const renewTokenRes = await partnerClient.config.oauthClient.renewAccessToken(session.access_mode === 'offline');
                renewTokenRes.access_token_validity = partnerClient.config.oauthClient.token_expires_at;
                session.updateToken(renewTokenRes);
                await SessionStorage.saveSession(session);
                logger.debug(`Access token renewed for organization ${organizationId}`);
            }
        }
        partnerClient.setExtraHeaders({
            'x-ext-lib-version': `js/${version}`
        })
        return partnerClient;
    }

    async getExtensionDetails() {

        let url = `${this.cluster}/service/panel/partners/v1.0/extensions/details/${this.api_key}`;
        const uniqueKey = `${url}`;

        const retryInfo = this._retryManager.retryInfoMap.get(uniqueKey);
        if (retryInfo && !retryInfo.isRetry) {
            this._retryManager.resetRetryState(uniqueKey);
        }

        try {
            const token = Buffer.from(
                `${this.api_key}:${this.api_secret}`,
                "utf8"
            ).toString("base64");
            const rawRequest = {
                method: "GET",
                url: url,
                headers: {
                    Authorization: `Basic ${token}`,
                    "Content-Type": "application/json",
                    'x-ext-lib-version': `js/${version}`
                },
            };
            let extensionData = await fdkAxios.request(rawRequest);
            logger.debug(`Extension details received: ${logger.safeStringify(extensionData)}`);
            this.extensionData = extensionData;
        } catch (err) {

            if (
                RetryManger.shouldRetryOnError(err) 
                && !this._retryManager.isRetryInProgress(uniqueKey)
            ) { 
                logger.debug(`API call failed. Starting retry for ${uniqueKey}`)
                return await this._retryManager.retry(uniqueKey, this.getExtensionDetails.bind(this));
            }

            throw new FdkInvalidExtensionConfig("Invalid api_key or api_secret. Reason:" + err.message);
        }
    }

    async updateExtensionBaseUrl(baseUrl) {
        const url = `${this.cluster}/service/panel/partners/v1.0/extensions/details/${this.api_key}`;
        const token = Buffer.from(
            `${this.api_key}:${this.api_secret}`,
            "utf8"
        ).toString("base64");

        try {
            await fdkAxios.request({
                method: "PATCH",
                url: url,
                headers: {
                    Authorization: `Basic ${token}`,
                    "Content-Type": "application/json",
                    'x-ext-lib-version': `js/${version}`
                },
                data: { base_url: baseUrl }
            });
            logger.debug(`Extension base_url synced to platform: ${baseUrl}`);
        } catch (err) {
            logger.warn(`Failed to sync base_url to platform: ${err.message}`);
        }
    }
}


const extension = new Extension();

module.exports = {
    extension
};