php graphql client

php graphql client

ไคลเอ็นต์ GraphQL ที่เขียนด้วย PHP ซึ่งมีคลาสตัวสร้างคิวรีที่เรียบง่ายแต่ทรงพลัง ซึ่งทำให้กระบวนการโต้ตอบกับเซิร์ฟเวอร์ GraphQL เป็นเรื่องง่ายมาก

การใช้งาน

มี 3 วิธีหลักในการใช้แพ็คเกจนี้เพื่อสร้างการสืบค้น GraphQL ของคุณ:

1. คลาสแบบสอบถาม: คลาสธรรมดาที่แมปกับแบบสอบถาม GraphQL ได้รับการออกแบบมาเพื่อจัดการข้อความค้นหาได้อย่างง่ายดายและรวดเร็ว
2. คลาส QueryBuilder: คลาสตัวสร้างที่สามารถใช้เพื่อสร้างวัตถุ Query แบบไดนามิก เป็นการออกแบบเพื่อใช้ในกรณีที่คิวรีถูกสร้างขึ้นในรูปแบบไดนามิก
3. PHP GraphQL-OQM: ส่วนขยายของแพ็คเกจนี้ ขจัดความจำเป็นในการเขียนคำสั่ง GraphQL หรืออ้างอิงถึงเอกสารประกอบหรือไวยากรณ์ API มันสร้างวัตถุแบบสอบถามจากสคีมา API การประกาศเปิดเผยผ่านการวิปัสสนาของ GraphQL ซึ่งสามารถโต้ตอบกับมันได้อย่างง่ายดาย

การติดตั้ง

รันคำสั่งต่อไปนี้เพื่อติดตั้งแพ็คเกจโดยใช้ผู้แต่ง:

 $ composer require gmostafa/php-graphql-client

ส่วนขยาย Object-to-Query-Mapper

เพื่อหลีกเลี่ยงความยุ่งยากในการต้องเขียนคำสั่ง ใดๆ และเพียงแค่โต้ตอบกับอ็อบเจ็กต์ PHP ที่สร้างจากสคีมา API ของคุณ โปรดไปที่พื้นที่เก็บข้อมูล PHP GraphQL OQM

ตัวอย่างแบบสอบถาม

แบบสอบถามง่ายๆ

 $ gql = ( new Query ( ' companies ' ))
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

แบบสอบถามง่ายๆ นี้จะดึงข้อมูลบริษัททั้งหมดที่แสดงชื่อและหมายเลขซีเรียลของตน

แบบฟอร์มเต็มรูปแบบ

ข้อความค้นหาที่ให้ไว้ในตัวอย่างก่อนหน้านี้แสดงอยู่ใน "รูปแบบชวเลข" รูปแบบชวเลขเกี่ยวข้องกับการเขียนจำนวนบรรทัดโค้ดที่ลดลงซึ่งจะช่วยเร่งกระบวนการเขียนแบบสอบถาม ด้านล่างนี้เป็นตัวอย่างของแบบฟอร์มแบบเต็มสำหรับข้อความค้นหาเดียวกันทุกประการที่เขียนในตัวอย่างก่อนหน้านี้

 $ gql = ( new Query ())
    -> setSelectionSet (
        [
            ( new Query ( ' companies ' ))
                -> setSelectionSet (
                    [
                        ' name ' ,
                        ' serialNumber '
                    ]
                )
        ]
    );

ดังที่เห็นในตัวอย่าง รูปแบบชวเลขจะอ่านและเขียนได้ง่ายกว่า โดยทั่วไปนิยมใช้มากกว่าเมื่อเทียบกับรูปแบบเต็ม

ไม่ควรใช้แบบฟอร์มแบบเต็ม เว้นแต่จะไม่สามารถแสดงแบบสอบถามในรูปแบบชวเลขซึ่งมีเพียงกรณีเดียว เมื่อเราต้องการเรียกใช้แบบสอบถามหลายรายการในออบเจ็กต์เดียวกัน

แบบสอบถามหลายรายการ

 $ gql = ( new Query ())
    -> setSelectionSet (
        [
            ( new Query ( ' companies ' ))
            -> setSelectionSet (
                [
                    ' name ' ,
                    ' serialNumber '
                ]
            ),
            ( new Query ( ' countries ' ))
            -> setSelectionSet (
                [
                    ' name ' ,
                    ' code ' ,
                ]
            )
        ]
    );

แบบสอบถามนี้จะดึงข้อมูลบริษัทและประเทศทั้งหมดที่แสดงช่องข้อมูลบางส่วนสำหรับแต่ละรายการ โดยพื้นฐานแล้วมันจะเรียกใช้แบบสอบถามอิสระสองรายการ (หรือมากกว่าหากจำเป็น) ในออบเจ็กต์แบบสอบถามเดียว

การเขียนแบบสอบถามหลายรายการจำเป็นต้องเขียนวัตถุแบบสอบถามในรูปแบบเต็มเพื่อแสดงแต่ละแบบสอบถามเป็นฟิลด์ย่อยภายใต้วัตถุแบบสอบถามหลัก

แบบสอบถามที่ซ้อนกัน

 $ gql = ( new Query ( ' companies ' ))
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber ' ,
            ( new Query ( ' branches ' ))
                -> setSelectionSet (
                    [
                        ' address ' ,
                        ( new Query ( ' contracts ' ))
                            -> setSelectionSet ([ ' date ' ])
                    ]
                )
        ]
    );

แบบสอบถามนี้เป็นแบบสอบถามที่ซับซ้อนมากขึ้น โดยไม่เพียงดึงข้อมูลเขตข้อมูลสเกลาร์เท่านั้น แต่ยังดึงข้อมูลเขตข้อมูลวัตถุด้วย แบบสอบถามนี้จะส่งคืนบริษัททั้งหมด โดยแสดงชื่อ หมายเลขซีเรียล และสำหรับแต่ละบริษัท สาขาทั้งหมด แสดงที่อยู่สาขา และสำหรับแต่ละที่อยู่ จะเรียกข้อมูลสัญญาทั้งหมดที่ผูกไว้กับที่อยู่นี้ โดยแสดงวันที่ของพวกเขา

แบบสอบถามด้วยอาร์กิวเมนต์

 $ gql = ( new Query ( ' companies ' ))
    -> setArguments ([ ' name ' => ' Tech Co. ' , ' first ' => 3 ])
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

แบบสอบถามนี้ไม่ได้ดึงข้อมูลบริษัททั้งหมดโดยการเพิ่มอาร์กิวเมนต์ แบบสอบถามนี้จะดึงข้อมูล 3 บริษัทแรกที่มีชื่อ "Tech Co. " ซึ่งแสดงชื่อและหมายเลขประจำเครื่อง

แบบสอบถามด้วยอาร์กิวเมนต์อาร์เรย์

 $ gql = ( new Query ( ' companies ' ))
    -> setArguments ([ ' serialNumbers ' => [ 159 , 260 , 371 ]])
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

แบบสอบถามนี้เป็นกรณีพิเศษของแบบสอบถามข้อโต้แย้ง ในตัวอย่างนี้ แบบสอบถามจะดึงข้อมูลเฉพาะบริษัทที่มีหมายเลขซีเรียลเป็น 159, 260 และ 371 ซึ่งแสดงชื่อและหมายเลขซีเรียล

แบบสอบถามด้วยอาร์กิวเมนต์วัตถุอินพุต

 $ gql = ( new Query ( ' companies ' ))
    -> setArguments ([ ' filter ' => new RawObject ( ' {name_starts_with: "Face"} ' )])
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

แบบสอบถามนี้เป็นอีกกรณีพิเศษของแบบสอบถามข้อโต้แย้ง ในตัวอย่างนี้ เรากำลังตั้งค่า "ตัวกรอง" ออบเจ็กต์อินพุตแบบกำหนดเองด้วยค่าบางค่าเพื่อจำกัดบริษัทที่ส่งคืน เรากำลังตั้งค่าตัวกรอง "name_starts_with" ด้วยค่า "Face" แบบสอบถามนี้จะดึงข้อมูลเฉพาะบริษัทที่มีชื่อขึ้นต้นด้วยวลี "ใบหน้า"

คลาส RawObject ที่กำลังสร้างใช้สำหรับการฉีดสตริงลงในแบบสอบถามตามที่เป็นอยู่ ไม่ว่าสตริงใดก็ตามที่ป้อนลงในตัวสร้าง RawObject จะถูกใส่ในแบบสอบถามเนื่องจากไม่มีการจัดรูปแบบแบบกำหนดเองใด ๆ ที่ปกติทำโดยคลาสแบบสอบถาม

แบบสอบถามด้วยตัวแปร

 $ gql = ( new Query ( ' companies ' ))
    -> setVariables (
        [
            new Variable ( ' name ' , ' String ' , true ),
            new Variable ( ' limit ' , ' Int ' , false , 5 )
        ]
    )
    -> setArguments ([ ' name ' => ' $name ' , ' first ' => ' $limit ' ])
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

แบบสอบถามนี้แสดงวิธีการใช้ตัวแปรในแพ็คเกจนี้เพื่ออนุญาตคำขอแบบไดนามิกที่เปิดใช้งานโดยมาตรฐาน GraphQL

คลาสตัวแปร

ระดับตัวแปรเป็นคลาสที่ไม่เปลี่ยนรูปซึ่งแสดงถึงตัวแปรในมาตรฐาน GraphQL ตัวสร้างของมันได้รับ 4 ข้อโต้แย้ง:

• ชื่อ: แสดงถึงชื่อตัวแปร
• ประเภท: แสดงถึงประเภทตัวแปรตามสคีมาเซิร์ฟเวอร์ GraphQL
• isRequired (ไม่บังคับ): แสดงว่าตัวแปรจำเป็นหรือไม่ โดยค่าเริ่มต้นจะเป็นเท็จ
• defaultValue (ไม่บังคับ): แสดงถึงค่าเริ่มต้นที่จะกำหนดให้กับตัวแปร ค่าเริ่มต้นจะได้รับการพิจารณาก็ต่อเมื่ออาร์กิวเมนต์ isRequired ถูกตั้งค่าเป็นเท็จ

การใช้นามแฝง

 $ gql = ( new Query ())
    -> setSelectionSet (
        [
            ( new Query ( ' companies ' , ' TechCo ' ))
                -> setArguments ([ ' name ' => ' Tech Co. ' ])
                -> setSelectionSet (
                    [
                        ' name ' ,
                        ' serialNumber '
                    ]
                ),
            ( new Query ( ' companies ' , ' AnotherTechCo ' ))
                -> setArguments ([ ' name ' => ' A.N. Other Tech Co. ' ])
                -> setSelectionSet (
                    [
                        ' name ' ,
                        ' serialNumber '
                    ]
                )
        ]
    );

นามแฝงสามารถตั้งค่าได้ในอาร์กิวเมนต์ที่สองของตัวสร้างแบบสอบถามสำหรับโอกาสที่จำเป็นต้องดึงออบเจ็กต์เดียวกันหลายครั้งด้วยอาร์กิวเมนต์ที่แตกต่างกัน

 $ gql = ( new Query ( ' companies ' ))
    -> setAlias ( ' CompanyAlias ' )
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );

นามแฝงสามารถตั้งค่าได้ด้วยวิธีการตั้งค่า

การใช้อินเทอร์เฟซ: สืบค้นด้วยแฟรกเมนต์แบบอินไลน์

เมื่อสืบค้นฟิลด์ที่ส่งคืนประเภทอินเทอร์เฟซ คุณอาจจำเป็นต้องใช้ส่วนย่อยแบบอินไลน์เพื่อเข้าถึงข้อมูลในประเภทคอนกรีตที่ซ่อนอยู่

ตัวอย่างนี้แสดงวิธีสร้างแฟรกเมนต์แบบอินไลน์โดยใช้แพ็คเกจนี้:

 $ gql = new Query ( ' companies ' );
$ gql -> setSelectionSet (
    [
        ' serialNumber ' ,
        ' name ' ,
        ( new InlineFragment ( ' PrivateCompany ' ))
            -> setSelectionSet (
                [
                    ' boardMembers ' ,
                    ' shareholders ' ,
                ]
            ),
    ]
);

ตัวสร้างแบบสอบถาม

คลาส QueryBuilder สามารถใช้เพื่อสร้างวัตถุ Query แบบไดนามิก ซึ่งอาจมีประโยชน์ในบางกรณี มันทำงานคล้ายกับคลาส Query มาก แต่การสร้าง Query แบ่งออกเป็นขั้นตอนต่างๆ

นั่นคือวิธีการสร้างตัวอย่าง "Query With Input Object Argument" โดยใช้ QueryBuilder:

 $ builder = ( new QueryBuilder ( ' companies ' ))
    -> setVariable ( ' namePrefix ' , ' String ' , true )
    -> setArgument ( ' filter ' , new RawObject ( ' {name_starts_with: $namePrefix} ' ))
    -> selectField ( ' name ' )
    -> selectField ( ' serialNumber ' );
$ gql = $ builder -> getQuery ();

เช่นเดียวกับคลาส Query นามแฝงสามารถตั้งค่าได้โดยใช้อาร์กิวเมนต์ตัวสร้างที่สอง

 $ builder = ( new QueryBuilder ( ' companies ' , ' CompanyAlias ' ))
    -> selectField ( ' name ' )
    -> selectField ( ' serialNumber ' );

$ gql = $ builder -> getQuery ();

หรือผ่านวิธีเซ็ตเตอร์

 $ builder = ( new QueryBuilder ( ' companies ' ))
    -> setAlias ( ' CompanyAlias ' )
    -> selectField ( ' name ' )
    -> selectField ( ' serialNumber ' );

$ gql = $ builder -> getQuery ();

แบบฟอร์มเต็มรูปแบบ

เช่นเดียวกับคลาส Query คลาส QueryBuilder สามารถเขียนในรูปแบบเต็มเพื่อให้สามารถเขียนหลายแบบสอบถามภายใต้วัตถุตัวสร้างแบบสอบถามเดียว ด้านล่างนี้คือตัวอย่างวิธีการใช้แบบฟอร์มแบบเต็มกับ QueryBuilder:

 $ builder = ( new QueryBuilder ())
    -> setVariable ( ' namePrefix ' , ' String ' , true )
    -> selectField (
        ( new QueryBuilder ( ' companies ' ))
            -> setArgument ( ' filter ' , new RawObject ( ' {name_starts_with: $namePrefix} ' ))
            -> selectField ( ' name ' )
            -> selectField ( ' serialNumber ' )
    )
    -> selectField (
        ( new QueryBuilder ( ' company ' ))
            -> setArgument ( ' serialNumber ' , 123 )
            -> selectField ( ' name ' )
    );
$ gql = $ builder -> getQuery ();

แบบสอบถามนี้เป็นส่วนขยายของแบบสอบถามในตัวอย่างก่อนหน้านี้ โดยจะส่งคืนบริษัททั้งหมดที่เริ่มต้นด้วยคำนำหน้าชื่อ และส่งคืนบริษัทด้วย serialNumber ค่า 123 ซึ่งทั้งสองบริษัทอยู่ในการตอบกลับเดียวกัน

การสร้างลูกค้า

สามารถสร้างอินสแตนซ์ของวัตถุไคลเอนต์ได้อย่างง่ายดายโดยการระบุ URL จุดสิ้นสุด GraphQL

ตัวสร้างไคลเอ็นต์ยังได้รับอาร์เรย์ "authorizationHeaders" ซึ่งเป็นตัวเลือก ซึ่งสามารถใช้เพื่อเพิ่มส่วนหัวการอนุญาตให้กับคำขอทั้งหมดที่ส่งไปยังเซิร์ฟเวอร์ GraphQL

ตัวอย่าง:

 $ client = new Client (
    ' http://api.graphql.com ' ,
    [ ' Authorization ' => ' Basic xyz ' ]
);

ตัวสร้างไคลเอ็นต์ยังได้รับอาร์เรย์ "httpOptions" ที่เป็นทางเลือก ซึ่ง จะแทนที่ "authorizationHeaders" และสามารถใช้เพื่อเพิ่มตัวเลือกคำขอ Guzzle HTTP Client ที่กำหนดเองได้

ตัวอย่าง:

 $ client = new Client (
    ' http://api.graphql.com ' ,
    [],
    [ 
        ' connect_timeout ' => 5 ,
        ' timeout ' => 5 ,
        ' headers ' => [
            ' Authorization ' => ' Basic xyz '
            'User-Agent' => ' testing/1.0 ' ,
        ],
        ' proxy ' => [
                ' http '  => ' tcp://localhost:8125 ' , // Use this proxy with "http"
                ' https ' => ' tcp://localhost:9124 ' , // Use this proxy with "https",
                ' no ' => [ ' .mit.edu ' , ' foo.com ' ]    // Don't use a proxy with these
        ],
        ' cert ' => [ ' /path/server.pem ' , ' password ' ]
        . . .
    ]
);

คุณสามารถใช้ไคลเอนต์ HTTP ที่กำหนดค่าไว้ล่วงหน้าของคุณเองซึ่งใช้อินเทอร์เฟซ PSR-18

ตัวอย่าง:

 $ client = new Client (
    ' http://api.graphql.com ' ,
    [],
    [],
    $ myHttpClient
);

กำลังเรียกใช้แบบสอบถาม

การจัดรูปแบบผลลัพธ์

เรียกใช้แบบสอบถามกับไคลเอนต์ GraphQL และรับผลลัพธ์ในโครงสร้างวัตถุ:

 $ results = $ client -> runQuery ( $ gql );
$ results -> getData ()-> companies [ 0 ]-> branches ;

หรือรับผลลัพธ์ในโครงสร้างอาร์เรย์:

 $ results = $ client -> runQuery ( $ gql , true );
$ results -> getData ()[ ' companies ' ][ 1 ][ ' branches ' ][ ' address ' ];

การส่งผ่านตัวแปรไปยังแบบสอบถาม

การเรียกใช้แบบสอบถามที่มีตัวแปรจำเป็นต้องผ่านอาร์เรย์ที่เชื่อมโยงซึ่งแมปชื่อตัวแปร (คีย์) ไปยังค่าตัวแปร (ค่า) ไปยังวิธี runQuery นี่คือตัวอย่าง:

 $ gql = ( new Query ( ' companies ' ))
    -> setVariables (
        [
            new Variable ( ' name ' , ' String ' , true ),
            new Variable ( ' limit ' , ' Int ' , false , 5 )
        ]
    )
    -> setArguments ([ ' name ' => ' $name ' , ' first ' => ' $limit ' ])
    -> setSelectionSet (
        [
            ' name ' ,
            ' serialNumber '
        ]
    );
$ variablesArray = [ ' name ' => ' Tech Co. ' , ' first ' => 5 ];
$ results = $ client -> runQuery ( $ gql , true , $ variablesArray );

การกลายพันธุ์

การกลายพันธุ์เป็นไปตามกฎเดียวกันของการสืบค้นใน GraphQL โดยจะเลือกฟิลด์บนออบเจ็กต์ที่ส่งคืน รับอาร์กิวเมนต์ และสามารถมีฟิลด์ย่อยได้

ต่อไปนี้คือตัวอย่างเกี่ยวกับวิธีสร้างและเรียกใช้การกลายพันธุ์:

 $ mutation = ( new Mutation ( ' createCompany ' ))
    -> setArguments ([ ' companyObject ' => new RawObject ( ' {name: "Trial Company", employees: 200} ' )])
    -> setSelectionSet (
        [
            ' _id ' ,
            ' name ' ,
            ' serialNumber ' ,
        ]
    );
$ results = $ client -> runQuery ( $ mutation );

ไคลเอ็นต์สามารถเรียกใช้การกลายพันธุ์ได้ในลักษณะเดียวกับที่เรียกใช้คิวรี

การกลายพันธุ์ด้วยตัวอย่างตัวแปร

การกลายพันธุ์สามารถใช้ตัวแปรในลักษณะเดียวกับที่แบบสอบถามสามารถทำได้ ต่อไปนี้คือตัวอย่างเกี่ยวกับวิธีใช้ตัวแปรเพื่อส่งผ่านออบเจ็กต์อินพุตไปยังเซิร์ฟเวอร์ GraphQL แบบไดนามิก:

 $ mutation = ( new Mutation ( ' createCompany ' ))
    -> setVariables ([ new Variable ( ' company ' , ' CompanyInputObject ' , true )])
    -> setArguments ([ ' companyObject ' => ' $company ' ]);

$ variables = [ ' company ' => [ ' name ' => ' Tech Company ' , ' type ' => ' Testing ' , ' size ' => ' Medium ' ]];
$ client -> runQuery (
    $ mutation , true , $ variables
);

สิ่งเหล่านี้คือผลลัพธ์ของการกลายพันธุ์และตัวแปรที่ส่งผ่านไปด้วย:

mutation( $ company : CompanyInputObject!) {
  createCompany (companyObject: $ company )
}
{"company":{"name":"Tech Company", " type " :"Testing", " size " :"Medium"}}

ตัวอย่าง API แบบสด

GraphQL Pokemon เป็น GraphQL API สาธารณะที่ยอดเยี่ยมมากซึ่งมีไว้เพื่อดึงข้อมูลโปเกมอน API พร้อมใช้งานแบบสาธารณะบนเว็บ เราจะใช้ API เพื่อสาธิตความสามารถของไคลเอ็นต์นี้

ลิงก์ Github Repo: https://github.com/lucasbento/graphql-pokemon

ลิงก์ API: https://graphql-pokemon.now.sh/

ข้อความค้นหานี้จะดึงข้อมูลวิวัฒนาการและการโจมตีของโปเกมอน:

query( $ name : String!) {
  pokemon (name: $ name ) {
    id
    number
    name
    evolutions {
      id
      number
      name
      weight {
        minimum
        maximum
      }
      attacks {
        fast {
          name
          type
          damage
        }
      }
    }
  }
}

นั่นคือวิธีการเขียนแบบสอบถามนี้โดยใช้คลาสแบบสอบถามและรันโดยใช้ไคลเอนต์:

 $ client = new Client (
    ' https://graphql-pokemon.now.sh/ '
);
$ gql = ( new Query ( ' pokemon ' ))
    -> setVariables ([ new Variable ( ' name ' , ' String ' , true )])
    -> setArguments ([ ' name ' => ' $name ' ])
    -> setSelectionSet (
        [
            ' id ' ,
            ' number ' ,
            ' name ' ,
            ( new Query ( ' evolutions ' ))
                -> setSelectionSet (
                    [
                        ' id ' ,
                        ' number ' ,
                        ' name ' ,
                        ( new Query ( ' attacks ' ))
                            -> setSelectionSet (
                                [
                                    ( new Query ( ' fast ' ))
                                        -> setSelectionSet (
                                            [
                                                ' name ' ,
                                                ' type ' ,
                                                ' damage ' ,
                                            ]
                                        )
                                ]
                            )
                    ]
                )
        ]
    );
try {
    $ name = readline ( ' Enter pokemon name: ' );
    $ results = $ client -> runQuery ( $ gql , true , [ ' name ' => $ name ]);
}
catch ( QueryError $ exception ) {
    print_r ( $ exception -> getErrorDetails ());
    exit ;
}
print_r ( $ results -> getData ()[ ' pokemon ' ]);

หรืออีกวิธีหนึ่ง นั่นคือวิธีการสร้างแบบสอบถามนี้โดยใช้คลาส QueryBuilder:

 $ client = new Client (
    ' https://graphql-pokemon.now.sh/ '
);
$ builder = ( new QueryBuilder ( ' pokemon ' ))
    -> setVariable ( ' name ' , ' String ' , true )
    -> setArgument ( ' name ' , ' $name ' )
    -> selectField ( ' id ' )
    -> selectField ( ' number ' )
    -> selectField ( ' name ' )
    -> selectField (
        ( new QueryBuilder ( ' evolutions ' ))
            -> selectField ( ' id ' )
            -> selectField ( ' name ' )
            -> selectField ( ' number ' )
            -> selectField (
                ( new QueryBuilder ( ' attacks ' ))
                    -> selectField (
                        ( new QueryBuilder ( ' fast ' ))
                            -> selectField ( ' name ' )
                            -> selectField ( ' type ' )
                            -> selectField ( ' damage ' )
                    )
            )
    );
try {
    $ name = readline ( ' Enter pokemon name: ' );
    $ results = $ client -> runQuery ( $ builder , true , [ ' name ' => $ name ]);
}
catch ( QueryError $ exception ) {
    print_r ( $ exception -> getErrorDetails ());
    exit ;
}
print_r ( $ results -> getData ()[ ' pokemon ' ]);

เรียกใช้แบบสอบถามดิบ

แม้ว่าจะไม่ใช่เป้าหมายหลักของแพ็คเกจนี้ แต่รองรับการรันคิวรีสตริงดิบ เช่นเดียวกับไคลเอนต์อื่น ๆ ที่ใช้วิธี runRawQuery ในคลาส Client นี่คือตัวอย่างเกี่ยวกับวิธีการใช้งาน:

 $ gql = <<<QUERY
query {
    pokemon(name: "Pikachu") {
        id
        number
        name
        attacks {
            special {
                name
                type
                damage
            }
        }
    }
}
QUERY ;

$ results = $ client -> runRawQuery ( $ gql );