M

MLOG

ಕನ್ನಡ

ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಸರ್ವರ್‌ಲೆಸ್ ಬ್ಯಾಕೆಂಡ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳುವುದು ಎಂದು ತಿಳಿಯಿರಿ. ಈ ಮಾರ್ಗದರ್ಶಿ ಮೂಲಭೂತ ಸೆಟಪ್‌ನಿಂದ ದೃಢೀಕರಣ, ಡೇಟಾ ನಿರ್ವಹಣೆ ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ನಿಭಾಯಿಸುವ ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು: ನಿಮ್ಮ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ಮಿಸುವುದು

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ತನ್ನ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ರಚನೆಯೊಂದಿಗೆ ಫ್ರಂಟ್-ಎಂಡ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡಿದೆ. ಆದರೆ ಇದು ಬ್ಯಾಕೆಂಡ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಹ ಗಣನೀಯವಾಗಿ ಸರಳಗೊಳಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆಯೇ? ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಸರ್ವರ್‌ಲೆಸ್ ಎಪಿಐ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದರಿಂದ ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪ್ರತ್ಯೇಕ ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ನ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಿಮ್ಮನ್ನು ಕರೆದೊಯ್ಯುತ್ತದೆ.

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು ಎಂದರೇನು?

ಎಪಿಐ ರೂಟ್‌ಗಳು ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಪ್ರಾಜೆಕ್ಟ್‌ನ /pages/api ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ನೀವು ರಚಿಸುವ ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಈ ಫಂಕ್ಷನ್‌ಗಳು ಒಳಬರುವ HTTP ವಿನಂತಿಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತವೆ ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕ ಬ್ಯಾಕೆಂಡ್ ಎಪಿಐನಂತೆಯೇ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ. ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಅವುಗಳನ್ನು ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ನೀವು ಸರ್ವರ್‌ಗಳು ಅಥವಾ ಮೂಲಸೌಕರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಫ್ರಂಟ್-ಎಂಡ್‌ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಹಗುರವಾದ, ಆನ್-ಡಿಮಾಂಡ್ ಬ್ಯಾಕೆಂಡ್ ಫಂಕ್ಷನ್‌ಗಳೆಂದು ಅವುಗಳನ್ನು ಪರಿಗಣಿಸಿ.

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ಒಂದು JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವ ಸರಳ ಎಪಿಐ ರೂಟ್ ಅನ್ನು ರಚಿಸೋಣ. ಮೊದಲಿಗೆ, ನೀವು ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಇಲ್ಲದಿದ್ದರೆ, ಇದನ್ನು ಬಳಸಿ ಒಂದನ್ನು ರಚಿಸಿ:

npx create-next-app my-app
cd my-app

ಈಗ, /pages/api ಡೈರೆಕ್ಟರಿಯೊಳಗೆ hello.js ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:

// pages/api/hello.js
export default function handler(req, res) {
  res.status(200).json({ name: 'John Doe' })
}

ಈ ಕೋಡ್ "John Doe" ಎಂಬ ಹೆಸರನ್ನು ಹೊಂದಿರುವ JSON ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವ ಸರಳ ಎಪಿಐ ರೂಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಈ ಎಪಿಐ ರೂಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು, ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ:

npm run dev

ನಂತರ, ನಿಮ್ಮ ಬ್ರೌಸರ್ ತೆರೆದು http://localhost:3000/api/hello ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ. ನೀವು ಈ ಕೆಳಗಿನ JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೋಡಬೇಕು:

{"name": "John Doe"}

ಎಪಿಐ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನಿಮ್ಮ ಎಪಿಐ ರೂಟ್‌ನಲ್ಲಿರುವ handler ಫಂಕ್ಷನ್ ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಪಡೆಯುತ್ತದೆ:

ವಿವಿಧ ರೀತಿಯ ವಿನಂತಿಗಳನ್ನು ನಿಭಾಯಿಸಲು, ವಿನಂತಿಯ ಬಾಡಿಯಿಂದ ಡೇಟಾವನ್ನು ಓದಲು, ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ವಿವಿಧ ರೀತಿಯ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಕಳುಹಿಸಲು ನೀವು ಈ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ವಿವಿಧ HTTP ವಿಧಾನಗಳನ್ನು ನಿಭಾಯಿಸುವುದು

ಒಳಬರುವ ವಿನಂತಿಯ HTTP ವಿಧಾನವನ್ನು ನಿರ್ಧರಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ನಿಭಾಯಿಸಲು ನೀವು req.method ಪ್ರಾಪರ್ಟಿಯನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

// pages/api/method.js
export default function handler(req, res) {
  if (req.method === 'GET') {
    // GET ವಿನಂತಿಯನ್ನು ನಿಭಾಯಿಸಿ
    res.status(200).json({ message: 'This is a GET request' })
  } else if (req.method === 'POST') {
    // POST ವಿನಂತಿಯನ್ನು ನಿಭಾಯಿಸಿ
    res.status(200).json({ message: 'This is a POST request' })
  } else {
    // ಇತರ ವಿಧಾನಗಳನ್ನು ನಿಭಾಯಿಸಿ
    res.status(405).json({ message: 'Method Not Allowed' })
  }
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಎಪಿಐ ರೂಟ್ GET ಮತ್ತು POST ಎರಡೂ ವಿನಂತಿಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ. ವಿನಂತಿಯ ವಿಧಾನ GET ಆಗಿದ್ದರೆ, ಅದು "This is a GET request" ಎಂಬ ಸಂದೇಶವನ್ನು ಹೊಂದಿರುವ JSON ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ವಿನಂತಿಯ ವಿಧಾನ POST ಆಗಿದ್ದರೆ, ಅದು "This is a POST request" ಎಂಬ ಸಂದೇಶವನ್ನು ಹೊಂದಿರುವ JSON ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ವಿನಂತಿಯ ವಿಧಾನ ಬೇರೆ ಯಾವುದಾದರೂ ಆಗಿದ್ದರೆ, ಅದು 405 Method Not Allowed ದೋಷದೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ.

ವಿನಂತಿಯ ಬಾಡಿಯಿಂದ ಡೇಟಾವನ್ನು ಓದುವುದು

POST, PUT, ಮತ್ತು PATCH ವಿನಂತಿಗಳಿಗಾಗಿ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ವಿನಂತಿಯ ಬಾಡಿಯಿಂದ ಡೇಟಾವನ್ನು ಓದಬೇಕಾಗುತ್ತದೆ. ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ JSON ಮತ್ತು URL-ಎನ್‌ಕೋಡೆಡ್ ವಿನಂತಿ ಬಾಡಿಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು ಅಂತರ್ಗತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ. JSON ವಿನಂತಿ ಬಾಡಿಯನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು, ನೀವು req.body ಪ್ರಾಪರ್ಟಿಯನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

// pages/api/post.js
export default async function handler(req, res) {
  if (req.method === 'POST') {
    const { name, email } = req.body

    // ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ
    console.log('Name:', name)
    console.log('Email:', email)

    res.status(200).json({ message: 'Data received successfully' })
  } else {
    res.status(405).json({ message: 'Method Not Allowed' })
  }
}

ಈ ಎಪಿಐ ರೂಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ನೀವು ಪೋಸ್ಟ್‌ಮ್ಯಾನ್ ಅಥವಾ ಕರ್ಲ್‌ನಂತಹ ಸಾಧನವನ್ನು ಬಳಸಿ JSON ಬಾಡಿಯೊಂದಿಗೆ POST ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಬಹುದು:

curl -X POST -H "Content-Type: application/json" -d '{"name": "Jane Doe", "email": "jane.doe@example.com"}' http://localhost:3000/api/post

ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್‌ಗಳನ್ನು ಹೊಂದಿಸುವುದು

ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು ನೀವು res.setHeader() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು. ಕಂಟೆಂಟ್ ಟೈಪ್, ಕ್ಯಾಶ್ ಕಂಟ್ರೋಲ್, ಮತ್ತು ಇತರ ಪ್ರಮುಖ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ:

// pages/api/headers.js
export default function handler(req, res) {
  res.setHeader('Content-Type', 'application/json')
  res.setHeader('Cache-Control', 's-maxage=3600')
  res.status(200).json({ message: 'Hello, world!' })
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಎಪಿಐ ರೂಟ್ Content-Type ಹೆಡರ್ ಅನ್ನು application/json ಗೆ ಹೊಂದಿಸುತ್ತದೆ, ಇದು ಪ್ರತಿಕ್ರಿಯೆಯು JSON ಆಬ್ಜೆಕ್ಟ್ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ಇದು Cache-Control ಹೆಡರ್ ಅನ್ನು s-maxage=3600 ಗೆ ಸಹ ಹೊಂದಿಸುತ್ತದೆ, ಇದು ಬ್ರೌಸರ್ ಮತ್ತು CDN ಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು 1 ಗಂಟೆಯವರೆಗೆ ಕ್ಯಾಶ್ ಮಾಡಲು ಹೇಳುತ್ತದೆ.

ದೋಷ ನಿರ್ವಹಣೆ

ನಿಮ್ಮ ಎಪಿಐ ರೂಟ್‌ಗಳಲ್ಲಿ ದೋಷಗಳನ್ನು ಸೌಜನ್ಯಯುತವಾಗಿ ನಿಭಾಯಿಸುವುದು ಮುಖ್ಯ. ವಿನಾಯಿತಿಗಳನ್ನು ಹಿಡಿಯಲು ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗೆ ಸೂಕ್ತ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಕಳುಹಿಸಲು ನೀವು try-catch ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

// pages/api/error.js
export default async function handler(req, res) {
  try {
    // ಒಂದು ದೋಷವನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡಿ
    throw new Error('Something went wrong')
  } catch (error) {
    console.error(error)
    res.status(500).json({ message: 'Internal Server Error' })
  }
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಎಪಿಐ ರೂಟ್ ಹೊಸ Error ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಎಸೆಯುವ ಮೂಲಕ ದೋಷವನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡುತ್ತದೆ. catch ಬ್ಲಾಕ್ ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತದೆ, ಅದನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗೆ 500 Internal Server Error ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಪ್ರೊಡಕ್ಷನ್ ಪರಿಸರಗಳಿಗಾಗಿ ಸೆಂಥ್ರಿ ಅಥವಾ ಡೇಟಾಡಾಗ್‌ನಂತಹ ದೃಢವಾದ ಲಾಗಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು

ಎಪಿಐ ರೂಟ್‌ಗಳಿಗಾಗಿ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಲ್ಲಿ ಒಂದು ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು. ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು ವಿವಿಧ ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತವೆ, ಅವುಗಳೆಂದರೆ:

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ನಲ್ಲಿ ಮಾಂಗೋಡಿಬಿ ಡೇಟಾಬೇಸ್‌ಗೆ ಹೇಗೆ ಸಂಪರ್ಕಿಸುವುದು ಎಂಬುದಕ್ಕೆ ಇಲ್ಲಿದೆ ಒಂದು ಉದಾಹರಣೆ:

// pages/api/mongodb.js
import { MongoClient } from 'mongodb'

const uri = process.env.MONGODB_URI
const options = {}

let client
let clientPromise

if (!process.env.MONGODB_URI) {
  throw new Error('Please add your Mongo URI to .env.local')
}

if (process.env.NODE_ENV === 'development') {
  // ಡೆವಲಪ್‌ಮೆಂಟ್ ಮೋಡ್‌ನಲ್ಲಿ, ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಬಳಸಿ, ಇದರಿಂದ ಮೌಲ್ಯವು
  // HMR (ಹಾಟ್ ಮಾಡ್ಯೂಲ್ ರಿಪ್ಲೇಸ್‌ಮೆಂಟ್) ನಿಂದ ಉಂಟಾಗುವ ಮಾಡ್ಯೂಲ್ ರೀಲೋಡ್‌ಗಳಾದ್ಯಂತ ಸಂರಕ್ಷಿಸಲ್ಪಡುತ್ತದೆ.
  if (!global._mongoClientPromise) {
    client = new MongoClient(uri, options)
    global._mongoClientPromise = client.connect()
  }
  clientPromise = global._mongoClientPromise
} else {
  // ಪ್ರೊಡಕ್ಷನ್ ಮೋಡ್‌ನಲ್ಲಿ, ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಬಳಸದಿರುವುದು ಉತ್ತಮ.
  client = new MongoClient(uri, options)
  clientPromise = client.connect()
}

// ಮಾಡ್ಯೂಲ್-ಸ್ಕೋಪ್ಡ್ MongoClient ಪ್ರಾಮಿಸ್ ಅನ್ನು ರಫ್ತು ಮಾಡಿ. ಇದನ್ನು ಪ್ರತ್ಯೇಕ
// ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಮಾಡುವುದರಿಂದ, ಕ್ಲೈಂಟ್ ಅನ್ನು ಬಹು ಫಂಕ್ಷನ್‌ಗಳಾದ್ಯಂತ ಸುರಕ್ಷಿತವಾಗಿ ಮರುಬಳಕೆ ಮಾಡಬಹುದು.
// ನೋಡಿ: https://github.com/vercel/next.js/blob/canary/examples/with-mongodb/lib/mongodb.js
export default async function handler(req, res) {
  try {
    const client = await clientPromise
    const db = client.db(process.env.MONGODB_DB)
    const collection = db.collection('users')

    const users = await collection.find({}).toArray()

    res.status(200).json({ users })
  } catch (e) {
    console.error(e)
    res.status(500).json({ message: 'Failed to fetch users' })
  }
}

ಈ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು, ನೀವು mongodb ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

npm install mongodb

ನೀವು MONGODB_URI ಮತ್ತು MONGODB_DB ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸಹ ಹೊಂದಿಸಬೇಕಾಗಿದೆ. ಈ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ನಿಮ್ಮ .env.local ಫೈಲ್‌ನಲ್ಲಿ (ಅಥವಾ ಪ್ರೊಡಕ್ಷನ್‌ಗಾಗಿ ನಿಮ್ಮ ಹೋಸ್ಟಿಂಗ್ ಪ್ರೊವೈಡರ್‌ನ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ) ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. MONGODB_URI ನಿಮ್ಮ ಮಾಂಗೋಡಿಬಿ ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು MONGODB_DB ಡೇಟಾಬೇಸ್ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ

ಭದ್ರತೆಗಾಗಿ ನಿಮ್ಮ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ರಕ್ಷಿಸುವುದು ನಿರ್ಣಾಯಕ. ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ವಿವಿಧ ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ ತಂತ್ರಗಳನ್ನು ಬಳಸಿ ಸುರಕ್ಷಿತಗೊಳಿಸಬಹುದು, ಅವುಗಳೆಂದರೆ:

JWT ದೃಢೀಕರಣವನ್ನು ಬಳಸಿ ಎಪಿಐ ರೂಟ್ ಅನ್ನು ಹೇಗೆ ರಕ್ಷಿಸುವುದು ಎಂಬುದಕ್ಕೆ ಇಲ್ಲಿದೆ ಒಂದು ಉದಾಹರಣೆ:

// pages/api/protected.js
import jwt from 'jsonwebtoken'

const secret = process.env.JWT_SECRET

export default function handler(req, res) {
  const token = req.headers.authorization?.split(' ')[1]

  if (!token) {
    return res.status(401).json({ message: 'Unauthorized' })
  }

  try {
    const decoded = jwt.verify(token, secret)
    // "decoded" ಆಬ್ಜೆಕ್ಟ್ ಟೋಕನ್‌ನಲ್ಲಿ ಅಳವಡಿಸಲಾದ ಬಳಕೆದಾರರ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ
    // ಉದಾಹರಣೆಗೆ: const userId = decoded.userId;

    // ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿ
    res.status(200).json({ message: 'Protected resource accessed successfully' })
  } catch (error) {
    return res.status(401).json({ message: 'Invalid token' })
  }
}

ಈ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು, ನೀವು jsonwebtoken ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

npm install jsonwebtoken

ನೀವು JWT_SECRET ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಸಹ ಹೊಂದಿಸಬೇಕಾಗಿದೆ. ಇದು JWTಗಳನ್ನು ಸಹಿ ಮಾಡಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ಬಳಸಲಾಗುವ ಒಂದು ಬಲವಾದ, ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚಿಸಲಾದ ರಹಸ್ಯ ಕೀ ಆಗಿರಬೇಕು. ಇದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಕೋಡ್‌ನಲ್ಲಿ ಎಂದಿಗೂ ಬಹಿರಂಗಪಡಿಸಬೇಡಿ.

ಮಿಡಲ್‌ವೇರ್

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಕ್ಸ್‌ಪ್ರೆಸ್.ಜೆಎಸ್ ನಂತೆ ಎಪಿಐ ರೂಟ್‌ಗಳಿಗಾಗಿ ಸಾಂಪ್ರದಾಯಿಕ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಒದಗಿಸದಿದ್ದರೂ, ನಿಮ್ಮ ಎಪಿಐ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ಸುತ್ತುವ ಮೂಲಕ ನೀವು ಇದೇ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಬಹುದು. ಇದು ನಿಮಗೆ ಈ ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ:

ಸರಳ ಲಾಗಿಂಗ್ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದಕ್ಕೆ ಇಲ್ಲಿದೆ ಒಂದು ಉದಾಹರಣೆ:

// utils/middleware.js
export function withLogging(handler) {
  return async function(req, res) {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`)
    return handler(req, res)
  }
}

ಈ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬಳಸಲು, ನಿಮ್ಮ ಎಪಿಐ ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು withLogging ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಸರಳವಾಗಿ ಸುತ್ತಿರಿ:

// pages/api/logged.js
import { withLogging } from '../../utils/middleware'

async function handler(req, res) {
  res.status(200).json({ message: 'This request was logged' })
}

export default withLogging(handler)

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸುಧಾರಿತ ತಂತ್ರಗಳು

ಹಿನ್ನೆಲೆ ಜಾಬ್‌ಗಳು

ಎಪಿಐ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನಿರ್ಬಂಧಿಸಬಾರದ ದೀರ್ಘಕಾಲದ ಕಾರ್ಯಗಳಿಗಾಗಿ, ಹಿನ್ನೆಲೆ ಜಾಬ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ನಿಮ್ಮ ಹಿನ್ನೆಲೆ ಜಾಬ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನೀವು BullMQ ಅಥವಾ Bree ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಬಹುದು.

ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳು

ರಿಯಲ್-ಟೈಮ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳಲ್ಲಿ ನೀವು ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. Socket.IO ಮತ್ತು ws ನಂತಹ ಲೈಬ್ರರಿಗಳು ಕ್ಲೈಂಟ್ ಮತ್ತು ಸರ್ವರ್ ನಡುವೆ ನಿರಂತರ ಸಂಪರ್ಕಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತವೆ.

ಗ್ರಾಫ್‌ಕ್ಯುಎಲ್

ಡೇಟಾವನ್ನು ಪಡೆಯಲು ನಿಮಗೆ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗ ಬೇಕಾದರೆ, ಗ್ರಾಫ್‌ಕ್ಯುಎಲ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಗ್ರಾಫ್‌ಕ್ಯುಎಲ್ ಎಪಿಐ ಎಂಡ್‌ಪಾಯಿಂಟ್ ರಚಿಸಲು ನೀವು ಅಪೊಲೊ ಸರ್ವರ್ ಅಥವಾ ಯೋಗಾದಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಬಹುದು.

ತೀರ್ಮಾನ

ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು ನಿಮ್ಮ ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಸರ್ವರ್‌ಲೆಸ್ ಬ್ಯಾಕೆಂಡ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸರ್ವರ್‌ಲೆಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಅಭಿವೃದ್ಧಿಯನ್ನು ಸರಳಗೊಳಿಸಬಹುದು, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ನೀವು ಸರಳ ಸಂಪರ್ಕ ಫಾರ್ಮ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ ಅಥವಾ ಸಂಕೀರ್ಣ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ನೆಕ್ಸ್ಟ್.ಜೆಎಸ್ ಎಪಿಐ ರೂಟ್‌ಗಳು ನಿಮಗೆ ಸುಲಭವಾಗಿ ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಬ್ಯಾಕೆಂಡ್ ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಮೂಲಭೂತ ಅಂಶಗಳ ದೃಢವಾದ ತಿಳುವಳಿಕೆ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಅನ್ವಯದೊಂದಿಗೆ, ನೀವು ಈ ಶಕ್ತಿಯುತ ಸಾಧನವನ್ನು ಬಳಸಿಕೊಂಡು ದಕ್ಷ, ಸುರಕ್ಷಿತ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.