JavaScript

Without Router - Current Approach

// Assuming this as previous logic without Router
const axios = require('axios');

const entityMetadataFromCR = {
    baseUrl: 'http://fip-1.dev.sahamati.org.in/fip-simulate',
    id: "FIP-SIMULATOR"
}

const getHttpConfig = ({ baseUrl, route, headers, data, methodType }) => {
    return { url: `${baseUrl}${route}`, headers: headers, data, methodType };
};

const executeDiscoveryRequest = () => {
    const route = '/v2/Accounts/discover';

    const config = getHttpConfig({ baseUrl: entityMetadataFromCR.baseUrl, route, headers: {}, data: {}, methodType: 'POST' });

    axios.request(config)
        .then(response => response.data)
        .catch(error => {
            console.error('Error making discovery request:', error.message);
            throw error;
        });

};

const performAnotherOperations = async (accountDiscoverResponse) => {
    console.log('Perform another operations with the response', accountDiscoverResponse);
}

executeDiscoveryRequest()
    .then(performAnotherOperations)
    .then(() => console.log('Account discovery successful.'))
    .catch(() => console.log('Account discovery failed.'))
    .finally(() => console.log('Account discovery completed.'));

With Router Integration - Request

const axios = require('axios');

// Entity metadata (from CR)
const entityMetadataFromCR = {
    baseUrl: 'http://fip-1.sandbox.sahamati.org.in/fip-simulate',
    id: 'FIP-SIMULATOR'
};

// Router Integration Helper URL
const ROUTER_INTEGRATION_HELPER_URL = 'https://api.sandbox.sahamati.org.in/router-helper/v1/request/header';

/**
 * Builds a base axios config
 */
const getHttpConfig = ({ baseUrl, route, headers = {}, data = {}, methodType = 'POST' }) => {
    return {
        url: `${baseUrl}${route}`,
        method: methodType,
        headers: {
            'Content-Type': 'application/json',
            ...headers
        },
        data
    };
};

/**
 * Calls Router Integration Helper Service to get host + x-request-meta
 */
const routerIntegrationHelper = async (route, rebitRequestBody) => {
    const payload = {
        rebitAPIEndpoint: route,
        recipientId: entityMetadataFromCR.id,
        customerId: '9875438980@AA_SIMULATOR',
        requestBody: rebitRequestBody
    };

    const response = await axios.post(ROUTER_INTEGRATION_HELPER_URL, payload, {
        headers: { 'Content-Type': 'application/json' }
    });

    return response.data; // { host, x-request-meta }
};

/**
 * Adds Sahamati Router headers + updates URL
 */
const addSahamatiConfiguration = async ({ config, route, rebitRequestBody }) => {
    const headerResponse = await routerIntegrationHelper(route, rebitRequestBody);

    const host = headerResponse.host;
    const xRequestMeta = headerResponse['x-request-meta'];

    config.url = `${host}${route}`;
    config.headers['x-request-meta'] = xRequestMeta;

    return config;
};

/**
 * Executes account discovery
 */
const executeDiscoveryRequest = async () => {
    const route = '/Accounts/discover';
    const rebitRequestBody = {}; // ReBIT defined request body

    let config = getHttpConfig({
        baseUrl: entityMetadataFromCR.baseUrl,
        route,
        headers: {},
        data: rebitRequestBody,
        methodType: 'POST'
    });

    // Add Sahamati configuration
    config = await addSahamatiConfiguration({ config, route, rebitRequestBody });

    const response = await axios.request(config);
    return response.data;
};

/**
 * Example: further operations after discovery
 */
const performAnotherOperations = async (accountDiscoverResponse) => {
    console.log('Next steps with response:', accountDiscoverResponse);
};

// Run discovery flow
(async () => {
    try {
        const response = await executeDiscoveryRequest();
        console.log('Account discovery successful:', response);

        await performAnotherOperations(response);
    } catch (error) {
        console.error('Account discovery failed. Error:', error.message);
    } finally {
        console.log('Account discovery completed.');
    }
})();

With Router Integration - Response

const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

const ROUTER_RESPONSE_HEADER_URL = 'https://api.sandbox.sahamati.org.in/router-helper/v1/response/header';
const RECIPIENT_ID = 'AA-SIMULATOR';

function fetchAccountFromRequestBody(requestBody) {
    if (!requestBody) return null;
    const customer = requestBody.Customer;
    if (!customer || typeof customer !== 'object') return null;
    const identifiers = customer.Identifiers;
    if (!Array.isArray(identifiers)) return null;
    for (const idObj of identifiers) {
        if (typeof idObj !== 'object') continue;
        const { category, type, value } = idObj;
        if (category === 'STRONG' && type === 'AADHAAR' && value) {
            return {
                FIType: 'DEPOSIT',
                accType: 'SAVINGS',
                accRefNumber: 'BANK11111111',
                maskedAccNumber: 'XXXXXXX3468',
            };
        }
    }
    return null;
}

async function routerIntegrationHelper(requestBody) {
    const resp = await axios.post(ROUTER_RESPONSE_HEADER_URL, requestBody, {
        headers: { 'Content-Type': 'application/json' },
        timeout: 30000,
    });
    return resp.data;
}

app.post('/accounts/discover', async (req, res) => {
    const incomingRequestBody = req.body;
    const discoveredAccount = fetchAccountFromRequestBody(incomingRequestBody);
    if (!discoveredAccount) {
        return res.status(404).json({ error: 'Account not found' });
    }
    const responseBody = {
        ver: '2.0.0',
        timestamp: new Date().toISOString(), // Use current timestamp
        txnid: 'f35761ac-4a18-11e8-96ff-0277a9fbfedcs',
        DiscoveredAccounts: [discoveredAccount],
    };
    const responseHeaderRequestBody = {
        rebitAPIEndpoint: '/accounts/discover',
        customerId: '9977336577@aa_simulator', // Optionally extract from incomingRequestBody
        recipientId: RECIPIENT_ID,
        additionalAttributes: {},
        responseBody,
    };
    try {
        const responseHeaderResp = await routerIntegrationHelper(responseHeaderRequestBody);
        const xResponseMeta = responseHeaderResp['x-response-meta'];
        if (xResponseMeta) {
            res.set('x-response-meta', xResponseMeta);
        }
    } catch (err) {
        // Optionally log error or handle as needed
    }
    res.json(responseBody);
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});