M

MLOG

தமிழ்

Next.js ரூட் ஹேண்ட்லர்களைப் பயன்படுத்தி சக்திவாய்ந்த API எண்ட்பாயிண்ட்களை உருவாக்குவது எப்படி என்பதை அறியுங்கள். இந்த வழிகாட்டி அடிப்படை அமைப்பு முதல் மேம்பட்ட நுட்பங்கள் வரை அனைத்தையும் நடைமுறை உதாரணங்கள் மற்றும் சிறந்த நடைமுறைகளுடன் உள்ளடக்கியுள்ளது.

Next.js ரூட் ஹேண்ட்லர்கள்: API எண்ட்பாயிண்ட் உருவாக்கத்திற்கான ஒரு விரிவான வழிகாட்டி

Next.js, சர்வர்-சைட் ரெண்டரிங், ஸ்டேடிக் சைட் ஜெனரேஷன், மற்றும் இப்போது, ரூட் ஹேண்ட்லர்கள் போன்ற அதன் சக்திவாய்ந்த அம்சங்களுடன் நாம் வலைப் பயன்பாடுகளை உருவாக்கும் விதத்தில் புரட்சியை ஏற்படுத்தியுள்ளது. ரூட் ஹேண்ட்லர்கள் உங்கள் Next.js பயன்பாட்டிற்குள் நேரடியாக API எண்ட்பாயிண்ட்களை உருவாக்க ஒரு நெகிழ்வான மற்றும் திறமையான வழியை வழங்குகின்றன. இந்த வழிகாட்டி ரூட் ஹேண்ட்லர்கள் பற்றிய கருத்து, அவற்றின் நன்மைகள், மற்றும் வலுவான API-களை உருவாக்க அவற்றை எவ்வாறு திறம்பட பயன்படுத்துவது என்பதை ஆராய்கிறது.

Next.js ரூட் ஹேண்ட்லர்கள் என்றால் என்ன?

ரூட் ஹேண்ட்லர்கள் என்பது ஒரு Next.js திட்டத்தின் app டைரக்டரிக்குள் வரையறுக்கப்பட்ட செயல்பாடுகள் ஆகும், அவை உள்வரும் HTTP கோரிக்கைகளைக் கையாளுகின்றன. பழைய pages/api அணுகுமுறையைப் போலல்லாமல் (இது API ரூட்களைப் பயன்படுத்துகிறது), ரூட் ஹேண்ட்லர்கள் உங்கள் ரியாக்ட் கூறுகளுடன் API எண்ட்பாயிண்ட்களை வரையறுக்க ஒரு நெறிப்படுத்தப்பட்ட மற்றும் நெகிழ்வான வழியை வழங்குகின்றன. அவை அடிப்படையில் எட்ஜ் அல்லது நீங்கள் தேர்ந்தெடுத்த சர்வர் சூழலில் செயல்படுத்தப்படும் சர்வர்லெஸ் ஃபங்ஷன்கள் ஆகும்.

ரூட் ஹேண்ட்லர்களை உங்கள் Next.js பயன்பாட்டின் பேக்கெண்ட் தர்க்கமாக நினையுங்கள், கோரிக்கைகளைச் செயலாக்குதல், தரவுத்தளங்களுடன் தொடர்புகொள்வது, மற்றும் பதில்களைத் திருப்புவது ஆகியவற்றிற்குப் பொறுப்பாகும்.

ரூட் ஹேண்ட்லர்களைப் பயன்படுத்துவதன் நன்மைகள்

உங்கள் Next.js திட்டத்தை அமைத்தல்

ரூட் ஹேண்ட்லர்களுக்குள் செல்வதற்கு முன், உங்களிடம் app டைரக்டரியுடன் ஒரு Next.js திட்டம் அமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். நீங்கள் ஒரு புதிய திட்டத்தைத் தொடங்குகிறீர்கள் என்றால், பின்வரும் கட்டளையைப் பயன்படுத்தவும்:

npx create-next-app@latest my-nextjs-app

புதிய ரூட்டிங் அமைப்பை இயக்க, அமைவு செயல்முறையின் போது app டைரக்டரியைத் தேர்ந்தெடுக்கவும்.

உங்கள் முதல் ரூட் ஹேண்ட்லரை உருவாக்குதல்

ஒரு JSON பதிலை வழங்கும் ஒரு எளிய API எண்ட்பாயிண்ட்டை உருவாக்குவோம். app டைரக்டரிக்குள் ஒரு புதிய டைரக்டரியை உருவாக்கவும், உதாரணமாக, /app/api/hello. இந்த டைரக்டரிக்குள், route.ts (அல்லது நீங்கள் டைப்ஸ்கிரிப்ட் பயன்படுத்தவில்லை என்றால் route.js) என்ற பெயரில் ஒரு கோப்பை உருவாக்கவும்.

உங்கள் முதல் ரூட் ஹேண்ட்லருக்கான குறியீடு இங்கே:

// app/api/hello/route.ts
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
 return NextResponse.json({ message: 'Next.js ரூட் ஹேண்ட்லர்களிடமிருந்து வணக்கம்!' });
}

விளக்கம்:

இப்போது, உங்கள் உலாவியில் /api/hello க்குச் செல்வதன் மூலம் அல்லது curl அல்லது Postman போன்ற ஒரு கருவியைப் பயன்படுத்துவதன் மூலம் இந்த எண்ட்பாயிண்ட்டை அணுகலாம்.

பல்வேறு HTTP முறைகளைக் கையாளுதல்

ரூட் ஹேண்ட்லர்கள் GET, POST, PUT, DELETE, PATCH, மற்றும் OPTIONS போன்ற பல்வேறு HTTP முறைகளை ஆதரிக்கின்றன. அதே route.ts கோப்பில் ஒவ்வொரு முறைக்கும் தனித்தனி செயல்பாடுகளை நீங்கள் வரையறுக்கலாம்.

// app/api/users/route.ts
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
 // தரவுத்தளத்திலிருந்து அனைத்து பயனர்களையும் மீட்டெடுப்பதற்கான தர்க்கம்
 const users = [{ id: 1, name: 'John Doe' }, { id: 2, name: 'Jane Smith' }]; // எடுத்துக்காட்டு தரவு
 return NextResponse.json(users);
}

export async function POST(request: Request) {
 const data = await request.json(); // கோரிக்கை அமைப்பை JSON ஆகப் பிரித்தல்
 // 'data'-வைப் பயன்படுத்தி தரவுத்தளத்தில் ஒரு புதிய பயனரை உருவாக்குவதற்கான தர்க்கம்
 const newUser = { id: 3, name: data.name, email: data.email }; // எடுத்துக்காட்டு
 return NextResponse.json(newUser, { status: 201 }); // புதிய பயனரை 201 Created ஸ்டேட்டஸ் குறியீட்டுடன் திருப்புதல்
}

விளக்கம்:

கோரிக்கை தரவை அணுகுதல்

request பொருள் உள்வரும் கோரிக்கை பற்றிய பல்வேறு தகவல்களுக்கு அணுகலை வழங்குகிறது, இதில் தலைப்புகள், வினவல் அளவுருக்கள் மற்றும் கோரிக்கை அமைப்பு ஆகியவை அடங்கும்.

தலைப்புகள்

request.headers பண்பைப் பயன்படுத்தி கோரிக்கை தலைப்புகளை நீங்கள் அணுகலாம்:

export async function GET(request: Request) {
 const userAgent = request.headers.get('user-agent');
 console.log('பயனர் முகவர்:', userAgent);
 return NextResponse.json({ userAgent });
}

வினவல் அளவுருக்கள்

வினவல் அளவுருக்களை அணுக, நீங்கள் URL கட்டமைப்பைப் பயன்படுத்தலாம்:

export async function GET(request: Request) {
 const url = new URL(request.url);
 const searchParams = new URLSearchParams(url.search);
 const id = searchParams.get('id');
 console.log('ID:', id);
 return NextResponse.json({ id });
}

கோரிக்கை அமைப்பு

POST, PUT, மற்றும் PATCH கோரிக்கைகளுக்கு, உள்ளடக்க வகையைப் பொறுத்து request.json() அல்லது request.text() முறைகளைப் பயன்படுத்தி கோரிக்கை அமைப்பை நீங்கள் அணுகலாம்.

export async function POST(request: Request) {
 const data = await request.json();
 console.log('தரவு:', data);
 return NextResponse.json({ receivedData: data });
}

பதில்களைத் திருப்புதல்

NextResponse பொருள் API பதில்களை உருவாக்கப் பயன்படுகிறது. இது தலைப்புகள், ஸ்டேட்டஸ் குறியீடுகள் மற்றும் பதில் அமைப்புகளை அமைப்பதற்கான பல முறைகளை வழங்குகிறது.

JSON பதில்கள்

JSON பதில்களைத் திருப்ப NextResponse.json() முறையைப் பயன்படுத்தவும்:

return NextResponse.json({ message: 'வெற்றி!', data: { name: 'John Doe' } }, { status: 200 });

உரை பதில்கள்

சாதாரண உரை பதில்களைத் திருப்ப new Response() கட்டமைப்பைப் பயன்படுத்தவும்:

return new Response('வணக்கம், உலகம்!', { status: 200, headers: { 'Content-Type': 'text/plain' } });

வழிமாற்றங்கள்

பயனர்களை வேறு URL-க்குத் திருப்பிவிட NextResponse.redirect() ஐப் பயன்படுத்தவும்:

import { redirect } from 'next/navigation';
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
 return NextResponse.redirect(new URL('/new-location', request.url));
}

தலைப்புகளை அமைத்தல்

NextResponse.json() அல்லது new Response() இல் உள்ள headers விருப்பத்தைப் பயன்படுத்தி நீங்கள் தனிப்பயன் தலைப்புகளை அமைக்கலாம்:

return NextResponse.json({ message: 'வெற்றி!' }, { status: 200, headers: { 'Cache-Control': 'no-cache' } });

மிடில்வேர் ஒருங்கிணைப்பு

மிடில்வேர் உங்கள் ரூட் ஹேண்ட்லரால் ஒரு கோரிக்கை கையாளப்படுவதற்கு முன்பு குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது. இது அங்கீகாரம், அங்கீகாரமளித்தல், பதிவுசெய்தல் மற்றும் பிற குறுக்கு வெட்டு கவலைகளுக்கு பயனுள்ளதாக இருக்கும்.

மிடில்வேரை உருவாக்க, app டைரக்டரி அல்லது எந்த துணை டைரக்டரியிலும் middleware.ts (அல்லது middleware.js) என்ற பெயரில் ஒரு கோப்பை உருவாக்கவும். மிடில்வேர் அந்த டைரக்டரி மற்றும் அதன் துணை டைரக்டரிகளில் உள்ள அனைத்து ரூட்களுக்கும் பொருந்தும்.

// app/middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
 const token = request.cookies.get('auth-token');

 if (!token) {
 return NextResponse.redirect(new URL('/login', request.url));
 }

 return NextResponse.next();
}

export const config = {
 matcher: ['/protected/:path*'], // இந்த மிடில்வேரை /protected/ உடன் தொடங்கும் பாதைகளுக்குப் பயன்படுத்தவும்
};

விளக்கம்:

பிழை கையாளுதல்

வலுவான API-களை உருவாக்க முறையான பிழை கையாளுதல் மிக முக்கியம். விதிவிலக்குகளைக் கையாள மற்றும் பொருத்தமான பிழை பதில்களைத் திருப்ப நீங்கள் try...catch தொகுதிகளைப் பயன்படுத்தலாம்.

export async function GET(request: Request) {
 try {
 // ஒரு பிழையை உருவகப்படுத்துங்கள்
 throw new Error('ஏதோ தவறு நடந்துவிட்டது!');
 } catch (error: any) {
 console.error('பிழை:', error);
 return NextResponse.json({ error: error.message }, { status: 500 });
 }
}

விளக்கம்:

ஸ்ட்ரீமிங் பதில்கள்

ரூட் ஹேண்ட்லர்கள் ஸ்ட்ரீமிங் பதில்களை ஆதரிக்கின்றன, இது வாடிக்கையாளருக்கு படிப்படியாக தரவை அனுப்ப உங்களை அனுமதிக்கிறது. இது குறிப்பாக பெரிய தரவுத்தொகுப்புகள் அல்லது நீண்ட நேரம் இயங்கும் செயல்முறைகளுக்கு பயனுள்ளதாக இருக்கும்.

import { Readable } from 'stream';
import { NextResponse } from 'next/server';

async function* generateData() {
 for (let i = 0; i < 10; i++) {
 await new Promise(resolve => setTimeout(resolve, 500)); // தாமதத்தை உருவகப்படுத்துங்கள்
 yield `தரவுத் துண்டு ${i}\n`;
 }
}

export async function GET(request: Request) {
 const readableStream = Readable.from(generateData());

 return new Response(readableStream, {
 headers: { 'Content-Type': 'text/plain; charset=utf-8' },
 });
}

விளக்கம்:

அங்கீகாரம் மற்றும் அங்கீகாரமளித்தல்

உங்கள் API எண்ட்பாயிண்ட்களைப் பாதுகாப்பது மிக முக்கியம். மிடில்வேரைப் பயன்படுத்தி அல்லது நேரடியாக உங்கள் ரூட் ஹேண்ட்லர்களுக்குள் அங்கீகாரம் மற்றும் அங்கீகாரமளித்தலை நீங்கள் செயல்படுத்தலாம்.

அங்கீகாரம்

அங்கீகாரம் கோரிக்கையைச் செய்யும் பயனரின் அடையாளத்தைச் சரிபார்க்கிறது. பொதுவான அங்கீகார முறைகள் பின்வருமாறு:

மிடில்வேரைப் பயன்படுத்தி JWT அங்கீகாரத்திற்கான ஒரு எடுத்துக்காட்டு இங்கே:

// app/middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET || 'your-secret-key'; // வலுவான, தோராயமாக உருவாக்கப்பட்ட இரகசியத்துடன் மாற்றவும்

export function middleware(request: NextRequest) {
 const token = request.cookies.get('auth-token')?.value;

 if (!token) {
 return NextResponse.json({ message: 'அங்கீகாரம் தேவை' }, { status: 401 });
 }

 try {
 jwt.verify(token, secret);
 return NextResponse.next();
 } catch (error) {
 return NextResponse.json({ message: 'தவறான டோக்கன்' }, { status: 401 });
 }
}

export const config = {
 matcher: ['/api/protected/:path*'],
};

அங்கீகாரமளித்தல்

அங்கீகாரமளித்தல் ஒரு பயனர் எந்த வளங்களை அணுக அனுமதிக்கப்படுகிறார் என்பதைத் தீர்மானிக்கிறது. இது பொதுவாக பாத்திரங்கள் அல்லது அனுமதிகளின் அடிப்படையில் இருக்கும்.

பயனரின் பாத்திரங்கள் அல்லது அனுமதிகளைச் சரிபார்த்து, அவர்களுக்கு அணுகல் இல்லையென்றால் ஒரு பிழையைத் திருப்பி அனுப்புவதன் மூலம் உங்கள் ரூட் ஹேண்ட்லர்களுக்குள் அங்கீகாரமளித்தலை நீங்கள் செயல்படுத்தலாம்.

// app/api/admin/route.ts
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
 // டோக்கன் அல்லது அமர்விலிருந்து பயனரின் பாத்திரத்தைப் பெற ஒரு செயல்பாடு இருப்பதாகக் கருதுங்கள்
 const userRole = await getUserRole(request);

 if (userRole !== 'admin') {
 return NextResponse.json({ message: 'அங்கீகரிக்கப்படாதது' }, { status: 403 });
 }

 // நிர்வாகத் தரவை மீட்டெடுப்பதற்கான தர்க்கம்
 const adminData = { message: 'நிர்வாகத் தரவு' };
 return NextResponse.json(adminData);
}

async function getUserRole(request: Request): Promise {
 // கோரிக்கையிலிருந்து பயனரின் பாத்திரத்தைப் பிரித்தெடுப்பதற்கான உங்கள் உண்மையான தர்க்கத்துடன் மாற்றவும்
 // இது ஒரு JWT டோக்கனைச் சரிபார்ப்பது அல்லது ஒரு அமர்வைச் சரிபார்ப்பதை உள்ளடக்கியிருக்கலாம்
 return 'admin'; // எடுத்துக்காட்டு: விளக்கத்திற்காக கடின குறியிடப்பட்ட பாத்திரம்
}

ரூட் ஹேண்ட்லர்களைப் வரிசைப்படுத்துதல்

ரூட் ஹேண்ட்லர்கள் நீங்கள் தேர்ந்தெடுத்த ஹோஸ்டிங் வழங்குநரில் சர்வர்லெஸ் ஃபங்ஷன்களாக வரிசைப்படுத்தப்படுகின்றன. Next.js Vercel, Netlify, AWS மற்றும் பல உள்ளிட்ட பல்வேறு வரிசைப்படுத்தல் தளங்களை ஆதரிக்கிறது.

Vercel-க்கு, உங்கள் Git களஞ்சியத்தை Vercel உடன் இணைத்து உங்கள் குறியீட்டைப் புஷ் செய்வது போல வரிசைப்படுத்தல் எளிது. Vercel தானாகவே உங்கள் Next.js திட்டத்தைக் கண்டறிந்து உங்கள் ரூட் ஹேண்ட்லர்களை சர்வர்லெஸ் ஃபங்ஷன்களாக வரிசைப்படுத்துகிறது.

மேம்பட்ட நுட்பங்கள்

எட்ஜ் ஃபங்ஷன்கள்

ரூட் ஹேண்ட்லர்களை எட்ஜ் ஃபங்ஷன்களாக வரிசைப்படுத்தலாம், அவை உங்கள் பயனர்களுக்கு நெருக்கமாக ஒரு CDN-இன் விளிம்பில் செயல்படுத்தப்படுகின்றன. இது தாமதத்தை கணிசமாகக் குறைத்து செயல்திறனை மேம்படுத்தும்.

ஒரு ரூட் ஹேண்ட்லரை எட்ஜ் ஃபங்ஷனாக வரிசைப்படுத்த, உங்கள் route.ts கோப்பில் edge இயக்க நேரத்தைச் சேர்க்கவும்:

export const runtime = 'edge';

import { NextResponse } from 'next/server';

export async function GET(request: Request) {
 return NextResponse.json({ message: 'எட்ஜிலிருந்து வணக்கம்!' });
}

சர்வர் ஆக்ஷன்ஸ்

சர்வர் ஆக்ஷன்ஸ் உங்கள் ரியாக்ட் கூறுகளிலிருந்து நேரடியாக சர்வர்-சைட் குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது. ரூட் ஹேண்ட்லர்கள் மற்றும் சர்வர் ஆக்ஷன்ஸ் தடையின்றி ஒன்றாக வேலை செய்கின்றன, இது சிக்கலான பயன்பாடுகளை எளிதாக உருவாக்க உங்களை அனுமதிக்கிறது.

ஒரு ரூட் ஹேண்ட்லரை அழைக்க ஒரு சர்வர் ஆக்ஷனைப் பயன்படுத்துவதற்கான ஒரு எடுத்துக்காட்டு இங்கே:

// app/components/MyComponent.tsx
'use client';
import { useState } from 'react';
import { useRouter } from 'next/navigation';

async function handleSubmit(data: FormData) {
 'use server';

 const name = data.get('name');
 const email = data.get('email');

 const response = await fetch('/api/users', {
 method: 'POST',
 body: JSON.stringify({ name, email }),
 });

 if (response.ok) {
 router.refresh(); // மாற்றங்களைப் பிரதிபலிக்க பக்கத்தைப் புதுப்பிக்கவும்
 }
}

export default function MyComponent() {
 const router = useRouter();

 return (
 

 
 


 
 


 
 

 );
}

கேச்சிங்

கேச்சிங் உங்கள் API எண்ட்பாயிண்ட்களின் செயல்திறனை கணிசமாக மேம்படுத்தும். உலாவிகள் மற்றும் CDN-களால் உங்கள் பதில்கள் எவ்வாறு கேச் செய்யப்படுகின்றன என்பதைக் கட்டுப்படுத்த Cache-Control தலைப்பைப் பயன்படுத்தலாம்.

return NextResponse.json({ message: 'வெற்றி!' }, { status: 200, headers: { 'Cache-Control': 'public, max-age=3600' } });

இந்த எடுத்துக்காட்டு Cache-Control தலைப்பை public, max-age=3600 ஆக அமைக்கிறது, இது உலாவிகள் மற்றும் CDN-களுக்கு பதிலை ஒரு மணி நேரத்திற்கு கேச் செய்யச் சொல்கிறது.

சிறந்த நடைமுறைகள்

நிஜ உலக உதாரணங்கள்

ரூட் ஹேண்ட்லர்கள் எவ்வாறு பயன்படுத்தப்படலாம் என்பதற்கான சில நிஜ உலக உதாரணங்கள் இங்கே:

சர்வதேச இ-காமர்ஸ் உதாரணம்: பயனரின் நாட்டின் அடிப்படையில் தயாரிப்பு விலையை மீட்டெடுக்கப் பயன்படுத்தப்படும் ஒரு ரூட் ஹேண்ட்லர். எண்ட்பாயிண்ட் பயனரின் இருப்பிடத்தைத் தீர்மானிக்க கோரிக்கையின் புவிஇருப்பிடத்தைப் (IP முகவரியிலிருந்து பெறப்பட்டது) பயன்படுத்தி, பொருத்தமான நாணயத்தில் விலைகளைத் திருப்பலாம். இது ஒரு உள்ளூர்மயமாக்கப்பட்ட ஷாப்பிங் அனுபவத்திற்கு பங்களிக்கிறது.

உலகளாவிய அங்கீகார உதாரணம்: உலகெங்கிலும் உள்ள பயனர்களுக்கான பல-காரணி அங்கீகாரத்தை (MFA) செயல்படுத்தும் ஒரு ரூட் ஹேண்ட்லர். இது SMS குறியீடுகளை அனுப்புவது அல்லது அங்கீகார பயன்பாடுகளைப் பயன்படுத்துவதை உள்ளடக்கியிருக்கலாம், அதே நேரத்தில் வெவ்வேறு பிராந்தியங்களின் தனியுரிமை விதிமுறைகள் மற்றும் தொலைத்தொடர்பு உள்கட்டமைப்புகளை மதிக்கிறது.

பன்மொழி உள்ளடக்க விநியோகம்: பயனரின் விருப்பமான மொழியில் உள்ளடக்கத்தை வழங்கும் ஒரு ரூட் ஹேண்ட்லர். இது கோரிக்கையில் உள்ள `Accept-Language` தலைப்பிலிருந்து தீர்மானிக்கப்படலாம். இந்த எடுத்துக்காட்டு சரியான UTF-8 குறியாக்கம் மற்றும் தேவைப்படும் இடங்களில் வலமிருந்து இடமாக மொழி ஆதரவின் தேவையை எடுத்துக்காட்டுகிறது.

முடிவுரை

Next.js ரூட் ஹேண்ட்லர்கள் உங்கள் Next.js பயன்பாட்டிற்குள் நேரடியாக API எண்ட்பாயிண்ட்களை உருவாக்க ஒரு சக்திவாய்ந்த மற்றும் நெகிழ்வான வழியை வழங்குகின்றன. ரூட் ஹேண்ட்லர்களைப் பயன்படுத்துவதன் மூலம், நீங்கள் எளிதாக வலுவான API-களை உருவாக்கலாம், உங்கள் பேக்கெண்ட் தர்க்கத்தை உங்கள் ரியாக்ட் கூறுகளுடன் இணைக்கலாம், மேலும் மிடில்வேர், ஸ்ட்ரீமிங் மற்றும் எட்ஜ் ஃபங்ஷன்கள் போன்ற அம்சங்களைப் பயன்படுத்திக் கொள்ளலாம்.

இந்த விரிவான வழிகாட்டி அடிப்படை அமைப்பு முதல் மேம்பட்ட நுட்பங்கள் வரை அனைத்தையும் உள்ளடக்கியுள்ளது. இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலம், பாதுகாப்பான, செயல்திறன் மிக்க மற்றும் பராமரிக்கக்கூடிய உயர்தர API-களை நீங்கள் உருவாக்கலாம்.