GraphQL Federation Code Review Best Practice — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

คืออะไร / บทนำ: แนวทางปฏิบัติที่แท้จริงในการรีวิวโค้ด GraphQL Federation ปี 2026

ในยุคที่ระบบซอฟต์แวร์มีความซับซ้อนและขยายตัวอย่างรวดเร็ว การพัฒนา GraphQL Federation ไม่ใช่แค่เรื่องของเทคนิค

แต่คือการสร้างระบบที่สามารถเติบโตได้อย่างยั่งยืน ด้วยประสบการณ์การเทรดและวิเคราะห์ระบบมาเกือบ 14 ปี ทั้งในตลาด Forex และการพัฒนาแอปพลิเคชันที่ต้องอาศัย API ประสิทธิภาพสูง อ.บอม ขอแบ่งปันแนวทางการรีวิวโค้ด (Code Review) สำหรับ GraphQL Federation ที่ได้ผลจริงในสภาพแวดล้อมจริง ไม่ใช่แค่ทฤษฎีจากหนังสือ

ในปี 2026 การรีวิวโค้ดไม่ใช่แค่การตรวจจับบั๊ก แต่คือกระบวนการประเมินคุณภาพของระบบในมิติต่าง ๆ ทั้งด้านสถาปัตยกรรม ความปลอดภัย การบำรุงรักษา และความสามารถในการขยายตัว สำหรับ GraphQL Federation ซึ่งเป็นแนวทางการรวม API จากหลายบริการเข้าด้วยกันอย่างมีระเบียบ การรีวิวจึงต้องเน้นที่ความสอดคล้องของ schema, การจัดการข้อมูลที่ถูกต้อง, และการป้องกันปัญหาที่อาจเกิดขึ้นในอนาคต เช่น การเรียกข้อมูลซ้ำ (N+1 queries) หรือการส่งข้อมูลเกินความจำเป็น

แนวทางหลักที่อ.บอม ใช้คือการตั้งเกณฑ์รีวิว (Review Checklist) ที่ครอบคลุมทุกมิติ เช่น ความชัดเจนของ schema ว่าใช้ `@key`, `@shareable`, และ `@provides` อย่างถูกต้องหรือไม่ ตรวจสอบว่า resolver ไม่ซ้อนกันเกินไป และมีการจัดการ error อย่างเหมาะสม ไม่ปล่อยให้เกิด error แบบไม่ระบุสาเหตุ (silent failure) ที่ทำให้ระบบหยุดทำงานโดยไม่มีสัญญาณเตือน

อีกประเด็นสำคัญคือการใช้แนวทาง Clean Code และ Design Patterns อย่างมีเหตุผล เช่น การใช้ Factory Pattern สำหรับสร้าง resolver หลายประเภทจาก interface เดียวกัน หรือการใช้ Repository Pattern เพื่อแยกตรรกะการเข้าถึงข้อมูลออกจากตรรกะธุรกิจ ทั้งหมดนี้ช่วยให้โค้ดอ่านง่าย แก้ไขได้เร็ว และลดความเหน็ดเหนื่อยของทีมพัฒนาในระยะยาว ซึ่งในโลกของการเทรดและพัฒนาระบบจริง การลดความเหน็ดเหนื่อยของทีมคือการเพิ่มผลผลิตอย่างแท้จริง

การรีวิวโค้ดในระบบที่ใช้ GraphQL Federation ต้องเริ่มจากการเข้าใจโครงสร้างพื้นฐานของระบบทั้งระบบ ไม่ใช่แค่ดูไฟล์เดียว แต่ต้องมองภาพรวมของ schema ทั้งหมด ว่าแต่ละ service รับผิดชอบอะไร และมีการเชื่อมโยงกันอย่างไรผ่าน `@key`, `@extends`, และ `@external` ซึ่งหากไม่เข้าใจโครงสร้างนี้ การรีวิวจะกลายเป็นการตรวจสอบเฉพาะจุด แล้วอาจพลาดข้อบกพร่องที่ซ่อนอยู่ในความสัมพันธ์ระหว่าง service

หลักการสำคัญประการแรกคือ ความสอดคล้องของ schema ทุกครั้งที่มีการเปลี่ยนแปลง schema ต้องมีการอัปเดตในทุก service ที่เกี่ยวข้อง ไม่ใช่แค่ในตัว service หลัก การใช้เครื่องมืออย่าง `@graphql-tools/stitch` หรือ `Apollo Federation` ช่วยให้สามารถตรวจสอบความสอดคล้องได้โดยอัตโนมัติ แต่การรีวิวยังต้องยืนยันว่าการเปลี่ยนแปลงนั้นส่งผลต่อ client อย่างไร และมีการจัดการ backward compatibility หรือไม่

ประการที่สองคือ ตรรกะของ resolver ต้องตรวจสอบว่า resolver แต่ละตัวทำหน้าที่เฉพาะเจาะจงหรือไม่ หากมีการรวมตรรกะหลายอย่างไว้ใน resolver เดียว เช่น การตรวจสอบสิทธิ์ การดึงข้อมูล และการจัดรูปแบบข้อมูล อาจทำให้โค้ดอ่านยาก และเกิดข้อผิดพลาดได้ง่ายในอนาคต ควรแยกตรรกะเหล่านี้ออกเป็น function ย่อยหรือใช้ middleware ที่เหมาะสม

ในระบบ GraphQL Federation ที่มีหลาย service การใช้ Design Patterns ไม่ใช่เพื่อความสวยงาม แต่เพื่อเพิ่มความยืดหยุ่น ลดความซับซ้อน และทำให้ระบบสามารถขยายตัวได้โดยไม่ล่ม ตัวอย่างที่พบบ่อยที่สุดคือ Singleton Pattern สำหรับการจัดการ connection เช่น database pool หรือ cache เช่น Redis ซึ่งต้องมีเพียง instance เดียวในทั้งระบบ เพื่อป้องกันการใช้ทรัพยากรเกินจำเป็น

อีก pattern ที่มีประโยชน์คือ Factory Pattern ซึ่งเหมาะกับการสร้าง resolver หลายประเภทจาก interface เดียวกัน เช่น ระบบการชำระเงินที่รองรับทั้ง Stripe, PayPal และ Omise โดยสามารถสร้าง factory ที่เลือกใช้ gateway ตามเงื่อนไข เช่น ประเทศปลายทาง หรือประเภทการชำระเงิน ซึ่งช่วยให้ระบบขยายได้โดยไม่ต้องแก้ไขโค้ดเดิม

Observer Pattern ก็มีบทบาทสำคัญในระบบ real-time เช่น การแจ้งเตือนเมื่อมีการเปลี่ยนแปลงข้อมูลใน GraphQL Federation ผ่าน subscription ซึ่งต้องมีการจัดการ event อย่างมีระบบ เช่น ใช้ WebSocket หรือ Pub/Sub messaging แทนการ poll ข้อมูลทุก 1 วินาที ซึ่งสิ้นเปลืองทรัพยากร

Builder Pattern ใช้ในการสร้าง query ที่ซับซ้อน เช่น การสร้าง dynamic filter หรือ pagination โดยไม่ต้องเขียนโค้ด query ยาว ๆ ทั้งหมดใน resolver ตัวอย่างเช่น การสร้าง query แบบมีเงื่อนไขหลายตัวพร้อมกัน โดยใช้ builder ที่สามารถ chain คำสั่งได้ ทำให้โค้ดอ่านง่ายและลดความผิดพลาด

สุดท้ายคือ Repository Pattern ที่ช่วยแยกตรรกะการเข้าถึงข้อมูลออกจากตรรกะธุรกิจ ทำให้สามารถเปลี่ยนแปลงฐานข้อมูลหรือ API ภายนอกได้โดยไม่กระทบต่อ resolver หลัก ซึ่งสำคัญมากในระบบ Federation ที่ข้อมูลมาจากหลายแหล่ง

Design Pattern	ใช้เมื่อ	ตัวอย่างจริง	ภาษาที่เหมาะ
Singleton	ต้องการ instance เดียวทั้งระบบ	Database connection pool, Logger	ทุกภาษา
Factory	สร้าง object หลายประเภทจาก interface เดียว	Payment gateway, Notification service	Java, C#, TypeScript
Builder	สร้าง object ซับซ้อนทีละขั้นตอน	Query builder, Form builder	Java, TypeScript

การรีวิวโค้ดที่ดีไม่ใช่แค่การหาบั๊ก แต่คือการสร้างวัฒนธรรมการเขียนโค้ดที่มีคุณภาพสูงในทีม ซึ่งต้องอาศัยแนวทางปฏิบัติที่ชัดเจนและสามารถนำไปใช้ได้จริงในทุกโปรเจกต์ ตัวอย่างเช่น การใช้ SOLID Principles เป็นกรอบการทำงานหลัก ซึ่งช่วยให้โค้ดยืดหยุ่นและบำรุงรักษาได้ง่าย

การรีวิวโค้ดที่ดีไม่ใช่แค่การหาบั๊ก แต่คือการสร้างวัฒนธรรมการเขียนโค้ดที่มีคุณภาพสูงในทีม

ซึ่งต้องอาศัยแนวทางปฏิบัติที่ชัดเจนและสามารถนำไปใช้ได้จริงในทุกโปรเจกต์ ตัวอย่างเช่น การใช้ SOLID Principles เป็นกรอบการทำงานหลัก ซึ่งช่วยให้โค้ดยืดหยุ่นและบำรุงรักษาได้ง่าย

การรีวิวโค้ดที่ดีไม่ใช่แค่การหาบั๊ก แต่คือการสร้างวัฒนธรรมการเขียนโค้ดที่มีคุณภาพสูงในทีม ซึ่งต้องอาศัยแนวทางปฏิบัติที่ชัดเจนและสามารถนำไปใช้ได้จริงในทุกโปรเจกต์ ตัวอย่างเช่น การใช้ SOLID Principles เป็นกรอบการทำงานหลัก ซึ่งช่วยให้โค้ดยืดหยุ่นและบำรุงรักษาได้ง่าย

Single Responsibility Principle (SRP) คือหลักการสำคัญที่สุด — แต่ละ function หรือ class ควรทำหน้าที่เพียงอย่างเดียว หากมีการรวมตรรกะหลายอย่างไว้ในที่เดียว เช่น การ validate input, เข้าถึงฐานข้อมูล และส่ง response ควรแยกออกเป็น function ย่อย ๆ เพื่อให้อ่านง่ายและทดสอบได้ง่ายขึ้น

Open/Closed Principle (OCP) หมายถึง ระบบควรเปิดสำหรับการขยาย (extension) แต่ปิดสำหรับการแก้ไข (modification) ซึ่งใน GraphQL Federation หมายถึง การออกแบบ schema และ resolver ให้สามารถเพิ่ม service ใหม่ได้โดยไม่ต้องเปลี่ยนโค้ดเดิม เช่น การใช้ interface หรือ abstract class แทนการเขียนโค้ดเฉพาะเจาะจง

Liskov Substitution Principle (LSP) ต้องการให้ subclass สามารถแทนที่ superclass ได้โดยไม่เปลี่ยนพฤติกรรมของระบบ ซึ่งมีผลต่อการใช้ interface ในการสร้าง resolver ที่สามารถสลับกันได้โดยไม่กระทบต่อการทำงานหลัก

Interface Segregation Principle (ISP) ช่วยให้ interface มีความเฉพาะเจาะจง ไม่รวมตรรกะที่ไม่จำเป็น ทำให้ resolver ที่ใช้ interface นั้นไม่ต้องรับตรรกะที่ไม่เกี่ยวข้อง

Dependency Inversion Principle (DIP) ต้องพึ่งพา abstraction ไม่ใช่ implementation โดยเฉพาะในระบบ Federation ควรใช้ dependency injection เพื่อให้สามารถเปลี่ยน service หรือ client ได้ง่ายในอนาคต

ในระบบ GraphQL Federation การทดสอบไม่ใช่แค่ unit test หรือ integration test แต่ต้องครอบคลุมทั้งระบบ (end-to-end) รวมถึงการทดสอบ schema ว่าสอดคล้องกันหรือไม่ และไม่ทำลาย client เดิมที่ใช้งานอยู่ ตัวอย่างเช่น การใช้ `graphql-tag` ร่วมกับ `jest` เพื่อทดสอบ resolver อย่างละเอียด

หนึ่งในเครื่องมือที่มีประสิทธิภาพคือ Schema Stitching Validation ซึ่งช่วยตรวจสอบว่า schema จากหลาย service สามารถรวมกันได้อย่างถูกต้องหรือไม่ โดยเฉพาะเมื่อมีการใช้ `@key` หรือ `@provides` ที่ต้องสอดคล้องกันทุกจุด

สมมติว่าเราอยู่ในทีมพัฒนาแอปพลิเคชันการเงินที่ใช้ GraphQL Federation เพื่อรวมข้อมูลจากบริการ User, Order, และ Payment ทั้งหมดทำงานบน microservices แยกต่างหาก

อีกประเด็นสำคัญคือ การตรวจสอบความปลอดภัย เช่น การตรวจสอบว่ามีการใช้ rate limiting, CORS, และ helmet middleware หรือไม่ รวมถึงการตรวจสอบว่ามีการป้องกัน GraphQL query explosion หรือการใช้ query ที่ซับซ้อนเกินไป (complexity analysis)

ในระบบ GraphQL Federation การทดสอบไม่ใช่แค่ unit test หรือ integration test แต่ต้องครอบคลุมทั้งระบบ (end-to-end) รวมถึงการทดสอบ schema

ว่าสอดคล้องกันหรือไม่ และไม่ทำลาย client เดิมที่ใช้งานอยู่ ตัวอย่างเช่น การใช้ `graphql-tag` ร่วมกับ `jest` เพื่อทดสอบ resolver อย่างละเอียด

การทดสอบและการตรวจสอบคุณภาพโค้ดในระบบ Federation

ในระบบ GraphQL Federation การทดสอบไม่ใช่แค่ unit test หรือ integration test แต่ต้องครอบคลุมทั้งระบบ (end-to-end) รวมถึงการทดสอบ schema ว่าสอดคล้องกันหรือไม่ และไม่ทำลาย client เดิมที่ใช้งานอยู่ ตัวอย่างเช่น การใช้ `graphql-tag` ร่วมกับ `jest` เพื่อทดสอบ resolver อย่างละเอียด

หนึ่งในเครื่องมือที่มีประสิทธิภาพคือ Schema Stitching Validation ซึ่งช่วยตรวจสอบว่า schema จากหลาย service สามารถรวมกันได้อย่างถูกต้องหรือไม่ โดยเฉพาะเมื่อมีการใช้ `@key` หรือ `@provides` ที่ต้องสอดคล้องกันทุกจุด

การทดสอบ schema ควรทำทุกครั้งที่มีการเปลี่ยนแปลงใน service ใด ๆ เพื่อป้องกันปัญหาที่เกิดจากการเปลี่ยนแปลงที่ไม่สอดคล้องกัน เช่น การลบ field ที่ client ยังใช้อยู่ หรือการเปลี่ยน type ของ field โดยไม่มี fallback

การใช้ Apollo Studio ช่วยให้สามารถติดตาม performance ของแต่ละ resolver ได้แบบเรียลไทม์ วัด latency, error rate, และ throughput ซึ่งช่วยให้รู้ว่ามีจุดใดที่ต้องปรับปรุง เช่น การเพิ่ม caching หรือการลดจำนวน query ที่เกิดขึ้น

การตรวจสอบความปลอดภัยควรครอบคลุมทั้งด้าน network และ application layer เช่น การใช้ rate limiting เพื่อป้องกันการโจมตีแบบ brute force การตั้งค่า CORS อย่างเหมาะสม และการใช้ helmet middleware เพื่อป้องกัน XSS และ CSRF

สมมติว่าเราอยู่ในทีมพัฒนาแอปพลิเคชันการเงินที่ใช้ GraphQL Federation เพื่อรวมข้อมูลจากบริการ User, Order, และ Payment ทั้งหมดทำงานบน microservices

แยกต่างหาก

การใช้ Observability เช่น logging, tracing, และ monitoring ช่วยให้สามารถติดตามพฤติกรรมของระบบในสภาพแวดล้อมจริงได้ ซึ่งสำคัญมากเมื่อระบบมีหลาย service และการเรียกข้อมูลผ่าน federation

ตัวอย่าง / ปฏิบัติจริง: การรีวิวโค้ดในโปรเจกต์จริง

สมมติว่าเราอยู่ในทีมพัฒนาแอปพลิเคชันการเงินที่ใช้ GraphQL Federation เพื่อรวมข้อมูลจากบริการ User, Order, และ Payment ทั้งหมดทำงานบน microservices แยกต่างหาก

ในกรณีนี้ การรีวิวโค้ดควรเริ่มจากการตรวจสอบว่าแต่ละ service ใช้ `@key` อย่างถูกต้องหรือไม่ โดยเฉพาะในบริการ User ที่ต้องใช้ `@key(fields: "id")` เพื่อให้ gateway สามารถ resolve user ได้จากหลายบริการ

ต่อมาตรวจสอบว่า resolver ที่เกี่ยวข้องกับการดึงข้อมูล order ใช้ `@provides` อย่างเหมาะสมหรือไม่ เช่น หาก Order service ต้องการให้ User service ให้ข้อมูล `name` และ `email` ต้องมีการระบุ `@provides(fields: "name email")` ไว้ใน resolver ของ Order

ในบริการ Payment ควรใช้ Factory Pattern เพื่อสร้าง gateway ตามประเทศปลายทาง เช่น ถ้าผู้ใช้จากไทย ให้ใช้ Omise, ถ้าจากยุโรป ให้ใช้ Stripe แทนการเขียน if-else ซับซ้อนใน resolver หลัก

การรีวิวควรตรวจสอบว่ามีการใช้ Repository Pattern หรือไม่ ว่าตรรกะการเข้าถึงข้อมูลจาก database หรือ API ภายนอกถูกแยกออกจากตรรกะธุรกิจหรือไม่

สุดท้าย ต้องตรวจสอบว่ามีการใช้ error boundary หรือ middleware ระดับสูงเพื่อจัดการ error แบบรวมศูนย์ และมีการบันทึก log อย่างเหมาะสม เพื่อให้ทีมพัฒนาสามารถวิเคราะห์ปัญหาได้ทันที

ตัวอย่างการรีวิวจริง: พบว่า resolver สำหรับดึงข้อมูล order รวมตรรกะการตรวจสอบสิทธิ์ การดึงข้อมูลจาก database และการจัดรูปแบบข้อมูลไว้ในที่เดียว จึงแนะนำให้แยกตรรกะออกเป็น middleware และ function ย่อย เพื่อให้โค้ดอ่านง่ายและทดสอบได้ง่ายขึ้น

คำถามที่พบบ่อย

การรีวิวโค้ด GraphQL Federation ควรตรวจสอบอะไรเป็นอันดับแรก?

การรีวิวโค้ด GraphQL Federation ควรเริ่มจากการตรวจสอบความสอดคล้องของ schema ทั้งระบบ ไม่ใช่แค่ดูไฟล์เดียว เพราะระบบ Federation ขึ้นอยู่กับการเชื่อมโยงระหว่างหลาย service ผ่าน directive เช่น `@key`, `@extends`, และ `@external` การตรวจสอบว่าแต่ละ service ระบุ `@key` อย่างถูกต้องหรือไม่ ถือเป็นหัวใจสำคัญ เพราะหาก schema ไม่สอดคล้องกัน จะเกิดปัญหาการ resolve ข้อมูลผิดพลาดหรือไม่สามารถรวมข้อมูลได้ใน gateway ที่กลาง นอกจากนี้ ต้องตรวจสอบว่าการเปลี่ยนแปลง schema ได้รับการอัปเดตในทุก service ที่เกี่ยวข้องอย่างครบถ้วน และมีการจัดการ backward compatibility อย่างเหมาะสม เพื่อไม่ให้ client เก่าหยุดทำงาน ซึ่งการละเลยจุดนี้อาจทำให้ระบบล่มในสภาพแวดล้อมจริงได้ ตัวอย่างเช่น หากมีการลบ field ที่ client ใช้อยู่โดยไม่มีการแจ้งเตือนหรือ fallback จะทำให้ client หยุดทำงานทันที ดังนั้น การใช้เครื่องมือเช่น Apollo Studio หรือ `@graphql-tools/stitch` เพื่อตรวจสอบ schema stitching จึงเป็นขั้นตอนจำเป็นที่ต้องทำก่อน merge code

ทำไมการแยกตรรกะใน resolver จึงสำคัญใน GraphQL Federation?

การแยกตรรกะใน resolver มีความสำคัญอย่างยิ่งใน GraphQL Federation เพราะ resolver ที่รวมตรรกะหลายอย่างไว้ในที่เดียว เช่น การตรวจสอบสิทธิ์ การดึงข้อมูลจาก database และการจัดรูปแบบข้อมูล จะทำให้โค้ดอ่านยาก แก้ไขได้ยาก และเสี่ยงต่อข้อผิดพลาดในอนาคต โดยเฉพาะเมื่อระบบมีการเปลี่ยนแปลงหรือขยายฟีเจอร์ ด้วยแนวทาง Clean Code การแยกตรรกะนี้ช่วยให้แต่ละส่วนมีความเฉพาะเจาะจง (Single Responsibility) ทำให้สามารถทดสอบได้ง่าย รีวิวได้รวดเร็ว และบำรุงรักษาง่ายขึ้น ตัวอย่างเช่น การแยกตรรกะการตรวจสอบสิทธิ์ออกเป็น middleware หรือ function ย่อย จะช่วยให้ resolver หลักมีความชัดเจนและอ่านง่าย ซึ่งสอดคล้องกับแนวคิดของ Design Patterns ที่ช่วยให้ระบบยืดหยุ่นและสามารถขยายตัวได้ในระยะยาว ยิ่งไปกว่านั้น การแยกตรรกะยังช่วยให้สามารถนำโค้ดไปใช้ซ้ำในบริการอื่นได้ ลดความซ้ำซ้อน และเพิ่มประสิทธิภาพการพัฒนาในทีม

ควรจัดการ error อย่างไรในระบบ GraphQL Federation เพื่อให้ client จัดการได้?

ในระบบ GraphQL Federation การจัดการ error ควรส่งข้อมูลที่มีความหมายและสามารถนำไปใช้ได้จริง โดยต้องหลีกเลี่ยงการส่ง error แบบไม่ระบุสาเหตุ (silent failure) หรือข้อความผิดพลาดที่สับสน เช่น “Internal Server Error” แทนที่ควรใช้ `GraphQLError` พร้อม field `extensions` ที่ระบุสาเหตุชัดเจน เช่น `code: "UNAUTHORIZED"` หรือ `code: "DATANOTFOUND"` ซึ่งช่วยให้ client สามารถตอบสนองได้อย่างเหมาะสม เช่น นำผู้ใช้กลับไปหน้าล็อกอิน หรือแสดงข้อความแจ้งเตือนที่ตรงจุด การรีวิวควรตรวจสอบว่ามีการใช้ error boundary หรือ middleware ระดับสูงเพื่อจัดการ error แบบรวมศูนย์ และมีการบันทึก log อย่างเหมาะสมเพื่อให้ทีมพัฒนาสามารถวิเคราะห์ปัญหาได้ทันที ซึ่งเป็นหัวใจสำคัญในการรักษาความเสถียรของระบบในสภาพแวดล้อมจริง

Factory Pattern ใช้ประโยชน์อย่างไรใน GraphQL Federation?

Factory Pattern ใช้ประโยชน์อย่างมีประสิทธิภาพใน GraphQL Federation โดยเฉพาะในกรณีที่ระบบต้องรองรับหลายช่องทางหรือบริการ เช่น การชำระเงินที่ต้องเชื่อมต่อกับ Stripe, PayPal หรือ Omise โดยสามารถสร้าง factory ที่เลือกใช้ gateway ตามเงื่อนไข เช่น ประเทศปลายทาง หรือประเภทการชำระเงิน แทนการเขียนตรรกะ if-else ซับซ้อนใน resolver หลัก ซึ่งช่วยให้โค้ดอ่านง่าย ขยายได้ง่าย และลดความเสี่ยงจากข้อผิดพลาดที่เกิดจากการเขียนเงื่อนไขซ้อนกัน การใช้ Factory Pattern ยังช่วยให้สามารถเพิ่ม gateway ใหม่ได้โดยไม่ต้องแก้ไขโค้ดเดิม ซึ่งสอดคล้องกับ Open/Closed Principle และทำให้ระบบยืดหยุ่นต่อการเปลี่ยนแปลงในอนาคต

แนะนำเพิ่มเติม

🎯 เปิดบัญชี XM Forex → สมัคร

📱 แอป iCafeFX → ดาวน์โหลด

📊 สัญญาณฟรี → รับสัญญาณ

📚 คู่มือเทรด → SiamCafeBook

🤝 สมัคร Partner XM → pipaffiliates.com/c?c=72816&l=th&p=6