REST APIs Sinhala: Beginners Guide to API Development & Usage | SC Guide

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ ඔයාලා හැමෝටම වැදගත් වෙන, Software Engineering ලෝකයේ නැතුවම බැරි මාතෘකාවක් ගැන. ඒ තමයි REST APIs. මේ නම ඇහෙනකොට සමහරුන්ට ටිකක් සංකීර්ණයි කියලා හිතෙන්න පුළුවන්. ඒත් මම අද ඔයාලට මේක පුළුවන් තරම් සරලව, අපේ සිංහලෙන්, ප්‍රායෝගික උදාහරණ එක්ක පැහැදිලි කරන්නම්. කෝපි කෝප්පයක් එහෙම තියාගෙනම මේ ලිපිය කියවන්න පටන් ගන්න. 😋

ඔයාලා කවදාවත් හිතුවද, ඔයාලගේ Facebook App එක Twitter එකත් එක්ක connect වෙන්නේ කොහොමද? නැත්නම්, ඔයා Online Food Delivery App එකකින් කෑම order කරනකොට, ඒ information එක Restaurant එකට යන්නේ කොහොමද කියලා? මේ හැමදේකටම පිටිපස්සේ ඉන්නේ මේ APIs (Application Programming Interfaces). විශේෂයෙන්ම, REST (Representational State Transfer) APIs කියන්නේ අද දවසේ Web Development වල, Mobile Application Development වල, සහ Cloud Computing වල බහුලවම භාවිත වෙන, ඉතාම වැදගත් සංකල්පයක්. ඔයාලා Online Banking App එකක් භාවිත කරනකොට, බස් ටිකට් එකක් Online ගන්නකොට, නැත්නම් Google Maps භාවිත කරනකොට, මේ හැම වෙලාවකම නොදැනුවත්වම REST API එකක් එක්ක තමයි interact වෙන්නේ.

මේ ලිපිය කියෙව්වට පස්සේ, ඔයාලට REST API කියන්නේ මොකක්ද, ඒක වැඩ කරන්නේ කොහොමද, ඒ වගේම ඒක ප්‍රායෝගිකව භාවිත කරන්නේ කොහොමද කියන එක ගැන හොඳ අවබෝධයක් ලැබෙයි. අපි එහෙනම් පටන් ගමු නේද?

REST API: මූලික සංකල්ප (Fundamental Concepts)

සරලව කිව්වොත්, API එකක් කියන්නේ විවිධ Software Application දෙකකට එකිනෙකා එක්ක කතා කරන්න, ඒ කියන්නේ data හුවමාරු කරගන්න උදව් කරන medium එකක්. හරියට Restaurant එකක Waiter කෙනෙක් වගේ. Customer (Client) කෑම (Request) order කරනවා, Waiter ඒක Kitchen (Server) එකට දෙනවා, Kitchen එක කෑම හදලා (Process) Waiter අතේ Customer ට (Response) දෙනවා. 🍜

REST API එකක් කියන්නේ, Client-Server communication වලදී භාවිත කරන විශේෂිත architecture style එකක්. මේක Web Services නිර්මාණය කරන්න බහුලවම භාවිත වෙනවා. REST API වල ප්‍රධානම ලක්ෂණ කිහිපයක් තියෙනවා:

1. Client-Server Architecture

REST API එකකදී Client (ඔයාගේ Browser, Mobile App) සහ Server (API එක තියෙන තැන, Database, Business Logic) කියන දෙක එකිනෙකාගෙන් වෙන් වෙලා තියෙනවා. මේ කියන්නේ Client එක Server එකේ data ගබඩා වෙලා තියෙන විදිහ ගැන දැනගන්න අවශ්‍ය නැහැ, ඒ වගේම Server එක Client ගේ user interface (UI) එක ගැන දැනගන්න අවශ්‍ය නැහැ. මේකෙන් ලැබෙන වාසිය තමයි, Client එකයි Server එකයි වෙන වෙනම develop කරලා deploy කරන්න පුළුවන් වීම. උදාහරණයක් විදිහට, ඔයාලට එකම Backend API එකක් භාවිත කරලා Mobile App එකක්, Web App එකක් සහ Desktop App එකක් පවා හදන්න පුළුවන්.

2. Stateless

මේක REST API වල තියෙන වැදගත්ම ලක්ෂණයක්. Server එක Client ගේ past requests ගැන කිසිම information එකක් මතක තියාගන්නේ නැහැ. ඒ කියන්නේ, හැම request එකක්ම වෙන වෙනම හඳුනාගෙන process කරනවා. හරියට ඔයා Restaurant එකට යන හැම වෙලාවෙම අලුතෙන් order කරනවා වගේ. කලින් order කරපු දේවල් Waiter ට මතක නැහැ. මේකෙන් ලැබෙන වාසිය තමයි Server එකට එකවර වැඩි requests ගණනකට handle කරන්න පුළුවන් වෙන එක. Scalability වැඩි වෙනවා.

3. Cacheable

Client ට ලැබෙන responses cache කරන්න පුළුවන් නම්, ඒක network traffic එක අඩු කරලා performance වැඩි කරනවා. සමහර වෙලාවට Server එකෙන් එන data එක නිතර වෙනස් වෙන්නේ නැහැ. එවැනි අවස්ථාවලදී, Client ට ඒ data එක තමන්ගේ තාවකාලික මතකයේ (cache) තියාගෙන, ඊළඟට ඒ data එක ඕන වුණාම Server එකට request නොකර cache එකෙන් ලබාගන්න පුළුවන්. මේකෙන් Client පැත්තේ response time එක අඩු වෙනවා.

4. Uniform Interface (ඒකාකාරී අතුරුමුහුණත)

මේක REST API වල වැදගත්ම ලක්ෂණයක්. ඒ කියන්නේ, API එකක් භාවිත කරන විදිහ standard එකකට අනුව හැදිලා තියෙනවා. මේක නිසා APIs තේරුම් ගන්න සහ භාවිත කරන්න පහසු වෙනවා. මේ Uniform Interface එකට ප්‍රධාන මූලධර්ම කිහිපයක් ඇතුළත් වෙනවා:

• Identification of Resources: හැම resource එකකටම (data item) unique URL එකක් තියෙන්න ඕනේ.
• Manipulation of Resources through Representations: Client එක resource එකක් manipulate (GET, POST, PUT, DELETE) කරන්නේ ඒ resource එකේ Representation එකක් Server එකට යවලා. මේ Representations බොහෝ විට JSON (JavaScript Object Notation) හෝ XML (Extensible Markup Language) formats වලින් තමයි තියෙන්නේ.
• Self-descriptive Messages: Client සහ Server අතර හුවමාරු වෙන හැම message එකක්ම තමන්වම describe කරගන්න ඕනේ. ඒ කියන්නේ message එකේ payload (data) විතරක් නෙවෙයි, ඒ data එක මොන type එකේ එකක්ද, මොන language එකෙන්ද වගේ meta-dataත් අඩංගු වෙන්න ඕනේ. (උදා: Content-Type: application/json)
• Hypermedia as the Engine of Application State (HATEOAS): මේක ටිකක් advanced සංකල්පයක්. Server එකේ response එක ඇතුළත, Client ට ඊළඟට මොන operations කරන්න පුළුවන්ද කියන එක ගැන links අඩංගු වෙනවා. (අපි මේ ලිපියේ මේ ගැන ගැඹුරට කතා කරන්නේ නැහැ, නමුත් මේ ගැන දැනුවත් වීම හොඳයි.)

REST API වල මූලික ක්‍රියාකාරීත්වය (Core Functionality)

REST API එකකදී data හඳුන්වන්නේ Resources විදිහට. මේ Resources වලට unique URLs (Uniform Resource Locators) තියෙනවා. අපි මේ Resources එක්ක interact වෙන්න HTTP Methods භාවිත කරනවා.

Resources and URLs

Resource එකක් කියන්නේ server එකේ තියෙන ඕනෑම data එකක්. උදාහරණයක් විදිහට, User කෙනෙක්, Product එකක්, Order එකක් වගේ දේවල් Resources වෙන්න පුළුවන්. මේ හැම Resource එකකටම URL එකක් තියෙනවා. මේ URLs එකිනෙකට වෙනස්. ඒවා බොහෝ විට noun (නාමපද) විදිහට තමයි design කරන්නේ, verbs (ක්‍රියාපද) විදිහට නෙවෙයි.

// Users කියන Resource එකේ URL එක (Plural Noun)
https://api.example.com/users

// ID එක 123 වෙන User ගේ URL එක (Specific Resource)
https://api.example.com/users/123

// Product එකක Reviews ටික (Nested Resource)
https://api.example.com/products/456/reviews

// වැරදි URL එකක් (Verb භාවිත කරලා)
https://api.example.com/getUsers  // ❌
https://api.example.com/createNewUser // ❌

HTTP Methods (Verbs)

මේවා තමයි Client එක Server එකට කියන්නේ මොකක්ද කරන්න ඕනේ කියලා. මේවාට HTTP Verbs කියලත් කියනවා. මේවා භාවිත කරලා අපි CRUD Operations (Create, Read, Update, Delete) කරනවා.

• GET: Server එකෙන් data request කරන්න (දත්ත ලබා ගැනීමට).උදා: GET /users - හැම User කෙනෙක්ම ලබා ගන්න.උදා: GET /users/123 - ID 123 තියෙන User ගේ විස්තර ලබා ගන්න.GET requests data වෙනස් කරන්නේ නැති නිසා ඒවා "Safe" operations ලෙස සලකනු ලැබේ.
• POST: Server එකට අලුත් data එකක් add කරන්න (දත්ත එකතු කිරීමට). සාමාන්‍යයෙන් new resource එකක් create කරන්න භාවිත කරනවා.උදා: POST /users - අලුත් User කෙනෙක්ව එකතු කරන්න.Request Body එකේ add කරන්න ඕනේ data එක තියෙනවා.
• PUT: Server එකේ තියෙන data එකක් update කරන්න (දත්ත යාවත්කාලීන කිරීමට). මේක සාමාන්‍යයෙන් Resource එකක් සම්පූර්ණයෙන්ම replace කරන්න භාවිත කරනවා.උදා: PUT /users/123 - ID 123 තියෙන User ගේ සම්පූර්ණ data update කරන්න.PUT requests "Idempotent" වේ. ඒ කියන්නේ, එකම PUT request එක කිහිප වතාවක් යැව්වත්, server එකේ අවසාන result එක එකම එකක් වෙනවා.
• DELETE: Server එකෙන් data එකක් remove කරන්න (දත්ත මකා දැමීමට).උදා: DELETE /users/123 - ID 123 තියෙන User ව delete කරන්න.DELETE requests ද Idempotent වේ.
• PATCH: Server එකේ තියෙන data එකක කොටසක් update කරන්න (සියල්ලම නොව, කොටසක් පමණක් යාවත්කාලීන කිරීමට).උදා: PATCH /users/123 - ID 123 තියෙන User ගේ Email එක විතරක් update කරන්න.

ප්‍රායෝගිකව REST API එකක් භාවිත කරන හැටි (Practical Usage)

අපි දැන් බලමු, ප්‍රායෝගිකව REST API එකක් භාවිත කරලා data ගන්නෙයි දෙන්නෙයි කොහොමද කියලා. Web Development වලදී, JavaScript වල fetch API එක භාවිත කරලා මේ දේවල් පහසුවෙන් කරන්න පුළුවන්. මේක Promises මත පදනම් වෙලා තියෙනවා. Postman, Insomnia, නැත්නම් ඔබේ Browser's Developer Tools (Network tab) වගේ tools භාවිත කරලත් API requests test කරන්න පුළුවන්.

GET Request එකක් කරන හැටි (Fetching Data)

අපි හිතමු අපිට Dummy JSON API එකකින් Products ලැයිස්තුවක් ගන්න ඕනේ කියලා. මේකට අපි GET method එක භාවිත කරනවා.

// Dummy JSON API එකකින් products ගන්න විදිහ
// Asynchronous JavaScript භාවිත කරමින්
async function getProducts() {
  try {
    const response = await fetch('https://dummyjson.com/products'); // GET request එක යවනවා
    
    if (!response.ok) {
      // response එක successful නැත්නම් error එකක් throw කරනවා
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json(); // response එක JSON format එකට convert කරනවා
    console.log('ලැබුණු දත්ත:', data.products); // data එක console එකේ පෙන්වනවා
    // මෙතනින් data එක භාවිත කරලා UI එක update කරන්න පුළුවන්
  } catch (error) {
    console.error('API call එකේදී error එකක් ආවා:', error); // error එකක් ආවොත් console එකේ පෙන්වනවා
    // Error message එක user ට පෙන්වන්න
  }
}

getProducts(); // function එක call කරනවා

මේ Code එකේදී වෙන්නේ:

1. async function getProducts() { ... }: අපි async function එකක් හදනවා. මේක නිසා await keyword එක භාවිත කරන්න පුළුවන්.
2. const response = await fetch('https://dummyjson.com/products');: මේ URL එකට GET request එකක් යවනවා. await keyword එක නිසා response එක එනකම් code execution එක pause වෙනවා.
3. if (!response.ok) { ... }: Server එකෙන් response එක successful (HTTP Status Code 2xx series එකේ) ද කියලා check කරනවා. response.ok කියන්නේ status code එක 200-299 අතරද කියලා.
4. const data = await response.json();: ලැබුණු response එක JSON object එකක් විදිහට convert කරනවා.
5. console.log('ලැබුණු දත්ත:', data.products);: JSON data එක ලැබුණම ඒක console එකේ පෙන්වනවා. දැන් අපිට data object එක භාවිත කරලා අවශ්‍ය දේවල් කරන්න පුළුවන්.
6. .catch(error => { ... }): API call එකේදී මොකක් හරි error එකක් ආවොත්, මේ block එක run වෙලා error එක console එකේ පෙන්වනවා.

POST Request එකක් කරන හැටි (Sending Data)

අපි දැන් බලමු අලුත් Product එකක් add කරන විදිහ. මේකට අපි POST method එක භාවිත කරනවා. Request Body එකේ අපි Server එකට යවන්න ඕනේ data එක JSON format එකෙන් තියෙන්න ඕනේ.

// අලුත් product එකක් add කරන්න
async function addProduct() {
  const newProduct = {
    title: 'Super Smart Watch',
    description: 'Track your health and stay connected.',
    price: 199.99,
    category: 'wearables'
  };

  try {
    const response = await fetch('https://dummyjson.com/products/add', {
      method: 'POST', // POST method එක භාවිත කරනවා
      headers: {
        'Content-Type': 'application/json', // අපි යවන data එක JSON කියලා Server එකට කියනවා
      },
      body: JSON.stringify(newProduct), // අපි Server එකට යවන data එක JSON string එකක් විදිහට convert කරනවා
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('නව Product එක සාර්ථකව එකතු කරන ලදී:', data); // Server එකෙන් එන response එක console කරනවා
    // සාමාන්‍යයෙන් successful POST request එකකින් return වෙන්නේ create කරපු resource එකේ data එකයි.
  } catch (error) {
    console.error('Product එක add කිරීමේදී error එකක් ආවා:', error);
  }
}

addProduct();

මේ Code එකේදී අලුතෙන් product එකක් එකතු කරන්න, අපි fetch function එකට දෙවෙනි argument එකක් විදිහට configuration object එකක් දෙනවා. ඒකේ method එක POST විදිහටයි, headers එක Content-Type: application/json විදිහටයි සකස් කරනවා. body එකට අපි යවන්න ඕන data එක JSON string එකක් විදිහට JSON.stringify() භාවිතයෙන් දෙනවා.

PUT Request එකක් කරන හැටි (Updating Data)

දැන් අපි බලමු තියෙන Product එකක Details update කරන හැටි. මේකට අපි PUT method එක භාවිත කරනවා. අපි update කරන්න ඕනේ Product එකේ ID එක URL එකේ සඳහන් කරනවා.

// Product එකක details update කරන්න
async function updateProduct() {
  const productId = 1; // update කරන්න ඕනේ product එකේ ID එක
  const updatedDetails = {
    title: 'Updated Super Smart Watch Pro',
    price: 249.99 // මිල update කරනවා
  };

  try {
    const response = await fetch(`https://dummyjson.com/products/${productId}`, {
      method: 'PUT', // PUT method එක භාවිත කරනවා
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(updatedDetails),
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('Product එක සාර්ථකව update කරන ලදී:', data);
  } catch (error) {
    console.error('Product එක update කිරීමේදී error එකක් ආවා:', error);
  }
}

updateProduct();

DELETE Request එකක් කරන හැටි (Deleting Data)

Product එකක් delete කරන හැටිත් බලමු. මේකට අපි DELETE method එක භාවිත කරනවා. මෙහිදී request body එකක් අවශ්‍ය වෙන්නේ නැහැ.

// Product එකක් delete කරන්න
async function deleteProduct() {
  const productId = 1; // delete කරන්න ඕනේ product එකේ ID එක

  try {
    const response = await fetch(`https://dummyjson.com/products/${productId}`, {
      method: 'DELETE', // DELETE method එක භාවිත කරනවා
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json(); // සාමාන්‍යයෙන් DELETE එකකින් හිස් response එකක් නැත්නම් confirmation message එකක් එනවා
    console.log('Product එක සාර්ථකව delete කරන ලදී:', data);
  } catch (error) {
    console.error('Product එක delete කිරීමේදී error එකක් ආවා:', error);
  }
}

deleteProduct();

HTTP Response Codes (තත්ව කේත)

API එකකට request එකක් යැව්වම, server එක response එකක් එක්ක HTTP Status Code එකක් එවනවා. මේ codes වලින් කියවෙන්නේ request එක successful ද, නැත්නම් මොකක් හරි error එකක් වුණාද කියලා. මේවා හරියට traffic lights වගේ. වැදගත් codes ටිකක් මෙන්න:

• 1xx Informational: Request එක ලැබුණා, process වෙනවා. (බොහෝ විට ඔබ මේවා දකින්නේ නැහැ.)
• 2xx Success: Request එක සාර්ථකයි.
  • 200 OK: Request එක සාර්ථකයි, data ලැබුණා. (හරි, යන්න පුළුවන්!)
  • 201 Created:0 Resource එකක් සාර්ථකව create කළා. (Successful POST!)
  • 204 No Content: Request එක සාර්ථකයි, නමුත් response body එකේ content නැහැ. (සාමාන්‍යයෙන් Successful DELETE හෝ PUT request එකකදී.)
• 3xx Redirection: Client එකට වෙනත් URL එකකට යන්න ඕනේ. (වෙන පාරකින් යන්න කියනවා.)
• 4xx Client Errors: Request එක වැරදියි, Client පැත්තේ ප්‍රශ්නයක්.
  • 400 Bad Request: Client ගෙන් ආපු request එක වැරදියි. (Syntax error, missing required data.)
  • 401 Unauthorized: Client ට authenticated වෙන්න බැහැ. (Login කරලා නැහැ, හැඳුනුම්පත නැහැ.)
  • 403 Forbidden: Client ට resource එකට access කරන්න අවසර නැහැ. (Login කරලා තිබ්බත් මේ දේ කරන්න අවසර නැහැ.)
  • 404 Not Found: ඉල්ලපු resource එක server එකේ නැහැ. (ගමනාන්තය හොයාගන්න බැහැ.)
  • 405 Method Not Allowed: භාවිත කරපු HTTP method එක මේ URL එකට අදාළ නැහැ. (උදා: POST කරන්න බැරි URL එකකට POST යැවීම.)
• 5xx Server Errors: Server එකේ මොකක් හරි ප්‍රශ්නයක්.
  • 500 Internal Server Error: Server එකේ මොකක් හරි අනපේක්ෂිත දෝෂයක්. (Server got problems.)
  • 503 Service Unavailable: Server එක තාවකාලිකව down වෙලා, නැත්නම් busy. (සේවාව තාවකාලිකව ලබාගත නොහැක.)

REST API භාවිතය සඳහා ප්‍රායෝගික උපදෙස් (Practical Tips)

REST API එක්ක වැඩ කරනකොට ඔයාලට වැදගත් වෙන තවත් දේවල් කිහිපයක් තියෙනවා:

• Error Handling: හැමවිටම error handling කරන්න පුරුදු වෙන්න. API call එක fail වුණොත්, user ට ඒක පැහැදිලිව දන්වන්න. (try...catch block එක සහ response.ok check එක අමතක කරන්න එපා.)
• Asynchronous Nature (Promises/Async-Await): API calls කියන්නේ Asynchronous operations. ඒ කියන්නේ request එක යවලා response එක එනකම් අනෙකුත් code execution එක block වෙන්නේ නැහැ. JavaScript වල Promises සහ async/await කියන features භාවිත කරලා මේ Asynchronous operations handle කරන්න පුළුවන්. අපේ උදාහරණ වල async/await භාවිත කළේ ඒ නිසයි.
• Authentication and Authorization: සැබෑ ලෝකයේදී බොහෝ APIs වලට authentication (ඔයා කවුද කියලා හඳුනා ගැනීම) සහ authorization (ඔයාට මේ දේ කරන්න අවසර තියෙනවද කියලා බලන එක) අවශ්‍ය වෙනවා. මේකට API Keys, OAuth, JWT (JSON Web Tokens) වගේ methods භාවිත කරනවා. මේවා Request Headers හරහා Server එකට යවනවා.
• CORS (Cross-Origin Resource Sharing): ඔයාගේ web application එකේ domain එකයි, API එකේ domain එකයි වෙනස් නම්, ඔයාලට CORS errors එන්න පුළුවන්. මේක Web Security feature එකක්. මේක handle කරන්න Server පැත්තේ adjustments කරන්න වෙනවා.
• Rate Limiting: සමහර APIs වලදී, ඔබට යම් කාල සීමාවක් තුළ කළ හැකි requests ගණන සීමා කරලා තියෙනවා. මේකට Rate Limiting කියලා කියනවා. ඔබ මේ සීමාව ඉක්මවා ගියහොත්, 429 Too Many Requests වගේ error එකක් එන්න පුළුවන්.
• API Versioning: API එකක් කාලයත් එක්ක වෙනස් වෙන්න පුළුවන්. ඒ නිසා API developers ලා API වල versions maintain කරනවා. (e.g., /api/v1/users, /api/v2/users). මේකෙන් client applications වලට breaking changes නැතුව update වෙන්න පුළුවන්.
• Documentation: හොඳ API එකක් කියන්නේ හොඳ documentation එකක් තියෙන එක. Swagger (OpenAPI) වගේ tools භාවිත කරලා API එකේ හැම endpoint එකක්ම, request/response formats, errors වගේ දේවල් පැහැදිලිව ලියලා තියෙන්න ඕනේ.
• API Testing Tools: Postman, Insomnia වගේ tools භාවිත කරලා API endpoints test කරන්න පුළුවන්. ඒක development process එකට ලොකු උදව්වක්.

අවසන් වශයෙන්...

අද අපි REST API කියන්නේ මොකක්ද, ඒකේ මූලික සංකල්ප, HTTP methods, සහ ප්‍රායෝගිකව JavaScript fetch API එක භාවිත කරලා requests කරන හැටි ගැන ගැඹුරින් ඉගෙන ගත්තා. මේක ඔයාලට Web Development ලෝකයේ තවත් පියවරක් ඉදිරියට යන්න ලොකු අත්වැලක් වෙයි කියලා මම විශ්වාස කරනවා.

REST API කියන්නේ සරල, බලවත් සහ Flexible architecture style එකක්. මේක Web Services නිර්මාණයට සහ විවිධ applications අතර data හුවමාරු කරගන්න අද බහුලවම භාවිත වෙනවා. ලංකාවේ වුණත්, බොහෝ startup සමාගම් සහ විශාල ආයතන ඔවුන්ගේ applications වලට REST APIs බහුලව භාවිත කරනවා.

ඔයාලා දැන් කරන්න ඕනේ මේ දේවල් තවදුරටත් practice කරන එක. Online තියෙන free APIs (උදා: DummyJSON, JSONPlaceholder, Reqres.in) භාවිත කරලා පොඩි project එකක් හදන්න උත්සාහ කරන්න. Browser console එකේ Network tab එක open කරලා, ඔයාලා දිනපතා භාවිත කරන applications (Facebook, YouTube, Google Search) කරන API calls මොන වගේද කියලා බලන්න. ඒකෙන් ඔයාලගේ දැනුම තවත් වැඩි කරගන්න පුළුවන්.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් Comment කරන්න. ඔයාලගේ අත්දැකීම් අපිත් එක්ක බෙදාගන්න. ඔයාලා මොන වගේ API project එකක්ද කරන්න හිතන් ඉන්නේ? අපි ඊළඟ ලිපියෙන් හම්බවෙමු! සුභ දවසක්! 🙏