หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

สร้าง schema graphql และตัวแก้ไขด้วย typeScript โดยใช้คลาสและนักตกแต่ง!

https://typegraphql.com

การแนะนำ

TypeGraphQl ทำให้การพัฒนา GraphQL APIs เป็นกระบวนการที่สนุกสนานเช่นการกำหนดสคีมาโดยใช้คลาสเฉพาะและเวทมนตร์ของมัณฑนากร

ดังนั้นในการสร้างประเภทเช่นประเภทวัตถุหรือประเภทอินพุตเราใช้คลาส DTO ชนิดหนึ่ง ตัวอย่างเช่นในการประกาศประเภท Recipe เราเพียงแค่สร้างชั้นเรียนและใส่คำอธิบายประกอบด้วยนักตกแต่ง: 

@ ObjectType ( )
class Recipe {
  @ Field ( type => ID )
  id : string ;

  @ Field ( )
  title : string ;

  @ Field ( type => [ Rate ] )
  ratings : Rate [ ] ;

  @ Field ( { nullable : true } )
  averageRating ?: number ;
}

และเราได้รับส่วนที่สอดคล้องกันของสคีมาใน SDL: 

 type Recipe {
  id : ID !
  title : String !
  ratings : [ Rate ! ] !
  averageRating : Float
}

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

@ Resolver ( Recipe )
class RecipeResolver {
  // dependency injection
  constructor ( private recipeService : RecipeService ) { }

  @ Query ( returns => [ Recipe ] )
  recipes ( ) {
    return this . recipeService . findAll ( ) ;
  }

  @ Mutation ( )
  @ Authorized ( Roles . Admin ) // auth guard
  removeRecipe ( @ Arg ( "id" ) id : string ) : boolean {
    return this . recipeService . removeById ( id ) ;
  }

  @ FieldResolver ( )
  averageRating ( @ Root ( ) recipe : Recipe ) {
    return recipe . ratings . reduce ( ( a , b ) => a + b , 0 ) / recipe . ratings . length ;
  }
}

และด้วยวิธีง่ายๆนี้เราได้รับส่วนนี้ของสคีมาใน SDL: 

 type Query {
  recipes : [ Recipe ! ] !
}

type Mutation {
  removeRecipe ( id : String ! ): Boolean !
}

แรงจูงใจ

เราทุกคนรู้ว่า GraphQL นั้นยอดเยี่ยมและแก้ปัญหามากมายที่เรามีกับ REST API เช่นการดึงข้อมูลและการดึงข้อมูลมากเกินไป แต่การพัฒนา graphQL API ใน node.js ด้วย typeScript บางครั้งก็เป็นอาการปวดเล็กน้อย ทำไม ลองมาดูขั้นตอนที่เราต้องทำ

ก่อนอื่นเราสร้างประเภท graphql ทั้งหมดใน schema.graphql โดยใช้ SDL จากนั้นเราสร้างแบบจำลองข้อมูลของเราโดยใช้คลาส ORM ซึ่งเป็นตัวแทนของเอนทิตี DB ของเรา จากนั้นเราเริ่มเขียนตัวแก้ไขสำหรับการสืบค้นการกลายพันธุ์และฟิลด์ของเรา แต่สิ่งนี้บังคับให้เราสร้างอินเทอร์เฟซ TS สำหรับอาร์กิวเมนต์อินพุตและประเภทวัตถุทั้งหมด

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

 export const getRecipesResolver : GraphQLFieldResolver < void , Context , GetRecipesArgs > = async (
  _ ,
  args ,
  ctx ,
) => {
  // common tasks repeatable for almost every resolver
  const repository = TypeORM . getRepository ( Recipe ) ;
  const auth = Container . get ( AuthService ) ;
  await joi . validate ( getRecipesSchema , args ) ;
  if ( ! auth . check ( ctx . user ) ) {
    throw new NotAuthorizedError ( ) ;
  }

  // our business logic, e.g.:
  return repository . find ( { skip : args . offset , take : args . limit } ) ;
} ;

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

เครื่องมือเช่น graphql code generator หรือ graphqlgen จะแก้ปัญหาส่วนแรกเท่านั้น-พวกเขาสร้างอินเทอร์เฟซที่เกี่ยวข้อง (และโครงกระดูกตัวแก้ไข) สำหรับ schema graphql ของเรา แต่พวกเขาไม่ได้แก้ไข schema <--> โมเดลความซ้ำซ้อนและประสบการณ์นักพัฒนา (การเปลี่ยนชื่อ F2 ไม่ทำงาน

TypeGraphql มาเพื่อแก้ไขปัญหาเหล่านี้ตามประสบการณ์จากไม่กี่ปีของการพัฒนา GraphQL APIs ใน TypeScript แนวคิดหลักคือการมีแหล่งความจริงเพียงแหล่งเดียวโดยการกำหนดสคีมาโดยใช้ชั้นเรียนและความช่วยเหลือจากนักตกแต่ง คุณสมบัติเพิ่มเติมเช่นการฉีดพึ่งพาการตรวจสอบความถูกต้องและการรับรองความถูกต้องช่วยงานร่วมกันซึ่งโดยปกติเราจะต้องจัดการกับตัวเอง

เอกสาร

เอกสารคู่มือการติดตั้งและคำอธิบายโดยละเอียดของ API และคุณสมบัติทั้งหมดมีอยู่ในเว็บไซต์

เริ่มต้น

คู่มือการเริ่มต้นใช้งานอย่างเต็มรูปแบบพร้อมคำแนะนำง่ายๆ (บทช่วยสอน) สามารถพบได้ในการเริ่มต้นเอกสาร

การสอนวิดีโอ

หากคุณชอบวิดีโอสอนคุณสามารถดูซีรีย์วิดีโอ TypeGraphql ของ Ben Awad บน YouTube

ตัวอย่าง

นอกจากนี้คุณยังสามารถตรวจสอบโฟลเดอร์ตัวอย่างในที่เก็บนี้สำหรับตัวอย่างเพิ่มเติมของการใช้งาน: Fields Resolvers แบบง่ายการสนับสนุนคอนเทนเนอร์ DI การรวม Typeorm การตรวจสอบความถูกต้องอัตโนมัติ ฯลฯ

โฟลเดอร์ทดสอบอาจให้คำแนะนำเกี่ยวกับวิธีการทำสิ่งต่าง ๆ ให้สำเร็จ

ข้อมูลการติดต่อด้านความปลอดภัย

หากต้องการรายงานช่องโหว่ด้านความปลอดภัยโปรดใช้ผู้ติดต่อ TideLift Security TideLift จะประสานงานการแก้ไขและการเปิดเผย

อนาคต

เวอร์ชันที่เปิดตัวในปัจจุบันคือการเปิดตัว 1.0.0 เสถียร ได้รับการทดสอบอย่างดี (ครอบคลุม 97%, ~ 500 กรณีทดสอบ) และมีคุณสมบัติส่วนใหญ่ที่วางแผนไว้แล้ว บริษัท มากมายและนักพัฒนาอิสระกำลังใช้ในการผลิตด้วยความสำเร็จ

อย่างไรก็ตามยังมีแผนสำหรับคุณสมบัติมากมายเช่น Typeorm ที่ดีกว่า, Prisma และ Dataloader Integration, Decorators Decorators และ Metadata Annotations รองรับ - รายการความคิดทั้งหมดมีอยู่ใน GitHub Repo นอกจากนี้คุณยังสามารถติดตามความคืบหน้าของการพัฒนาบนกระดานโครงการ

หากคุณมีคำขอคุณสมบัติที่น่าสนใจอย่าลังเลที่จะเปิดปัญหาเกี่ยวกับ GitHub เพื่อให้เราสามารถพูดคุยกันได้!

สนับสนุน

TypeGraphql เป็นโครงการโอเพ่นซอร์สที่ได้รับอนุญาตจาก MIT เฟรมเวิร์กนี้เป็นผลมาจากการทำงานจำนวนมาก - คืนนอนไม่หลับตอนเย็นที่ยุ่งและวันหยุดสุดสัปดาห์

มันไม่มี บริษัท ขนาดใหญ่ที่อยู่ข้างหลัง - การพัฒนาอย่างต่อเนื่องเป็นไปได้เพียงต้องขอบคุณการสนับสนุนของชุมชน

ผู้สนับสนุนทองคำ?

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

ผู้สนับสนุนเงิน?

ชุมชน

  • เยี่ยมชมเว็บไซต์อย่างเป็นทางการ
  • แชทบน Discord

ต้องการความช่วยเหลือ?

ต้องการยื่นข้อผิดพลาดมีส่วนร่วมในรหัสหรือปรับปรุงเอกสาร? ยอดเยี่ยม! โปรดอ่านแนวทางของเราสำหรับการบริจาคแล้วตรวจสอบหนึ่งในปัญหาความช่วยเหลือของเรา

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด