如何将Node.js项目对接至已上线的StrongLoop API？

Hey there! Let me walk you through the key steps to integrate an existing StrongLoop API into your new Node.js project—this is something I’ve helped folks with a bunch of times, so let’s break it down simply and practically.

Before writing any code, take 10 minutes to get clear on the API’s details:

• Endpoints: List out all the paths you need (e.g., /api/users, /api/orders). Use curl or Postman to test them first—this helps you confirm they’re live and understand response formats.
  Example curl test:

  curl -X GET https://your-strongloop-api.com/api/your-model
  

• Authentication: Note if it uses JWT tokens, API keys, or basic auth. Most StrongLoop APIs use JWT, so you’ll need a valid token (usually from a login endpoint like /api/users/login).
• Request/Response Schemas: Jot down the required fields for POST/PUT requests, and the structure of the JSON responses you’ll get back.

For making HTTP requests, axios is the most straightforward choice (node-fetch works too, but axios has built-in interceptors for auth which is handy). Install it first:

npm install axios

Next, create a reusable API client file (e.g., strongloop-api-client.js) to avoid repeating config everywhere:

const axios = require('axios');

// Initialize the client with your API base URL and auth headers
const strongLoopClient = axios.create({
  baseURL: 'https://your-strongloop-api.com/api',
  headers: {
    // Adjust based on your API's auth method
    'Authorization': 'Bearer YOUR_VALID_JWT_TOKEN',
    'Content-Type': 'application/json'
  }
});

module.exports = strongLoopClient;

Here’s how to implement common actions with your client:

• Fetch a list of records

const strongLoopClient = require('./strongloop-api-client');

async function fetchAllRecords() {
  try {
    const response = await strongLoopClient.get('/your-model');
    console.log('Fetched records:', response.data);
    return response.data;
  } catch (error) {
    // Handle errors properly—StrongLoop returns detailed error messages in response.data
    console.error('Failed to fetch records:', error.response?.data || error.message);
    throw error; // Re-throw if you want upstream code to handle it
  }
}

// Call the function
fetchAllRecords();

• Create a new record

async function createNewRecord(recordData) {
  try {
    const response = await strongLoopClient.post('/your-model', recordData);
    console.log('Created record:', response.data);
    return response.data;
  } catch (error) {
    console.error('Failed to create record:', error.response?.data || error.message);
    throw error;
  }
}

// Example usage
createNewRecord({ name: 'New Product', price: 29.99, inStock: true });

• Update an existing record

async function updateRecord(recordId, updatedData) {
  try {
    // Use PATCH for partial updates, PUT for full replacements
    const response = await strongLoopClient.patch(`/your-model/${recordId}`, updatedData);
    console.log('Updated record:', response.data);
    return response.data;
  } catch (error) {
    console.error('Failed to update record:', error.response?.data || error.message);
    throw error;
  }
}

// Example usage
updateRecord('123abc', { price: 34.99 });

• Delete a record

async function deleteRecord(recordId) {
  try {
    await strongLoopClient.delete(`/your-model/${recordId}`);
    console.log('Record deleted successfully');
  } catch (error) {
    console.error('Failed to delete record:', error.response?.data || error.message);
    throw error;
  }
}

// Example usage
deleteRecord('123abc');

If your API uses JWT tokens that expire, add an interceptor to refresh tokens automatically—this saves you from writing refresh logic in every function:

// Add this to your strongloop-api-client.js file
strongLoopClient.interceptors.response.use(
  response => response, // Pass through successful responses
  async (error) => {
    const originalRequest = error.config;

    // Only retry once if we get a 401 (unauthorized) error
    if (error.response.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;

      // Fetch a new token using your refresh token (adjust this to your API's login endpoint)
      const refreshResponse = await axios.post('https://your-strongloop-api.com/api/users/login', {
        refreshToken: 'YOUR_REFRESH_TOKEN'
      });

      const newToken = refreshResponse.data.id;
      // Update the client's auth header with the new token
      strongLoopClient.defaults.headers.common['Authorization'] = `Bearer ${newToken}`;

      // Retry the original request with the new token
      return strongLoopClient(originalRequest);
    }

    // If it's not a 401, or we already retried, pass the error along
    return Promise.reject(error);
  }
);

To make sure the API returns data in the format you expect, use a validation library like joi to check responses:

npm install joi

Then add validation to your functions:

const Joi = require('joi');

// Define a schema that matches your API's record structure
const recordSchema = Joi.object({
  id: Joi.string().required(),
  name: Joi.string().required(),
  price: Joi.number().positive().required(),
  inStock: Joi.boolean().required()
});

async function fetchAllRecords() {
  try {
    const response = await strongLoopClient.get('/your-model');
    
    // Validate each record in the response
    response.data.forEach(record => {
      const { error } = recordSchema.validate(record);
      if (error) {
        console.warn('Invalid record found:', error.details[0].message);
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to fetch records:', error.response?.data || error.message);
    throw error;
  }
}

内容的提问来源于stack exchange，提问作者badman123