ดาวน์โหลด parse server - parse server Source Download

การแยกวิเคราะห์หัว-เซิร์ฟเวอร์

สร้างสถานะ

Parse Server เป็นแบ็กเอนด์โอเพ่นซอร์สที่สามารถปรับใช้กับโครงสร้างพื้นฐานใด ๆ ที่สามารถเรียกใช้ node.js Parse Server ทำงานร่วมกับ Framework แอปพลิเคชันเว็บด่วน สามารถเพิ่มลงในเว็บแอปพลิเคชันที่มีอยู่หรือดำเนินการด้วยตัวเอง

เอกสารฉบับเต็มสำหรับ Parse Server มีอยู่ใน Wiki คู่มือเซิร์ฟเวอร์ Parse เป็นสถานที่ที่ดีในการเริ่มต้น นอกจากนี้ยังมีคู่มืออ้างอิง API และคลาวด์รหัส หากคุณสนใจที่จะพัฒนาสำหรับเซิร์ฟเวอร์ Parse คู่มือการพัฒนาจะช่วยให้คุณได้รับการตั้งค่า

ขอขอบคุณ ผู้สนับสนุนและผู้สนับสนุนที่สนับสนุนการพัฒนาแพลตฟอร์มการแยกวิเคราะห์!

ผู้สนับสนุนบรอนซ์

รสชาติและสาขา
- การสนับสนุนระยะยาว
เริ่มต้น
- ใช้เซิร์ฟเวอร์แยกวิเคราะห์
  - ความเข้ากันได้
    - node.js
    - MongoDB
    - PostgreSQL
  - ในระดับท้องถิ่น
  - คอนเทนเนอร์ Docker
  - บันทึกวัตถุ
  - เชื่อมต่อ SDK
- เรียกใช้เซิร์ฟเวอร์แยกวิเคราะห์ที่อื่น
  - แอปพลิเคชันตัวอย่าง
  - Parse Server + Express
- Parse Server Health
  - ค่าสถานะ
การกำหนดค่า
- ตัวเลือกพื้นฐาน
- ตัวเลือกคีย์ไคลเอนต์
- เข้าถึงขอบเขต
- การยืนยันอีเมลและรีเซ็ตรหัสผ่าน
- นโยบายรหัสผ่านและบัญชี
- เส้นทางที่กำหนดเอง
  - ตัวอย่าง
  - เส้นทางที่สงวนไว้
  - พารามิเตอร์
- หน้ากำหนดเอง
- การใช้ตัวแปรสภาพแวดล้อม
- อะแดปเตอร์ที่มีอยู่
- การกำหนดค่าอะแดปเตอร์ไฟล์
- การบังคับใช้ idempotency
- การแปลเป็นภาษาท้องถิ่น
  - หน้า
    - การแปลด้วยโครงสร้างไดเรกทอรี
    - การแปลด้วยทรัพยากร JSON
    - ตัวยึดตำแหน่งแบบไดนามิก
    - คีย์ที่สงวนไว้
    - พารามิเตอร์
- การตัดไม้
การคัดค้าน
แบบสอบถามสด
graphql
- วิ่ง
  - ใช้ CLI
  - ใช้นักเทียบท่า
  - ใช้ Express.js
- ตรวจสอบสุขภาพของ API
- การสร้างชั้นหนึ่งของคุณ
- ใช้การดำเนินการที่สร้างขึ้นโดยอัตโนมัติ
- ปรับแต่ง schema graphql ของคุณ
- เรียนรู้เพิ่มเติม
การบริจาค
ผู้มีส่วนร่วม
ผู้สนับสนุน
ผู้สนับสนุน

รสชาติและสาขา

Parse Server มีอยู่ในรสชาติที่แตกต่างกันในสาขาที่แตกต่างกัน:

สาขาหลักคือการเปิดตัวเบต้าและอัลฟ่า ดูภาพรวมการเปลี่ยนแปลงสำหรับรายละเอียด
สาขาการสนับสนุนระยะยาว (LTS) มีชื่อว่า release-<version>.xx ตัวอย่างเช่น release-5.xx สาขา LTS ไม่มีสาขาก่อนวางจำหน่าย

การสนับสนุนระยะยาว

การสนับสนุนระยะยาว (LTS) มีไว้สำหรับเวอร์ชันหลักของเซิร์ฟเวอร์แยกวิเคราะห์ก่อนหน้า ตัวอย่างเช่น Parse Server 5.x จะได้รับการอัปเดตความปลอดภัยจนกว่า Parse Server 6.x จะถูกแทนที่ด้วย Parse Server 7.x และกลายเป็นเวอร์ชัน LTS ใหม่ ในขณะที่รุ่นหลักปัจจุบันถูกเผยแพร่ใน release สาขารุ่น LTS จะถูกเผยแพร่ในสาขา release-#.xx ตัวอย่างเช่น release-5.xx สำหรับ Server Parse 5.x LTS Branch

มีการจัดเตรียมเวอร์ชัน LTS เพื่อช่วยให้คุณเปลี่ยนแปลงโดยเร็วที่สุดเท่าที่จะเป็นไปได้ ในขณะที่เราตั้งเป้าหมายที่จะแก้ไขช่องโหว่ด้านความปลอดภัยในเวอร์ชัน LTS แต่จุดสนใจหลักของเราคือการพัฒนาเวอร์ชันหลักปัจจุบันและการเตรียมการเปิดตัวครั้งใหญ่ครั้งต่อไป ดังนั้นเราอาจทิ้งช่องโหว่บางอย่างไว้ที่ชุมชนเพื่อแก้ไข ค้นหาคำขอดึงด้วยสาขาฐาน LTS เฉพาะเพื่อดูช่องโหว่แบบเปิดปัจจุบันสำหรับสาขา LTS นั้น

เริ่มต้น

วิธีที่เร็วและง่ายที่สุดในการเริ่มต้นคือการเรียกใช้ MongoDB และ Parse Server ในเครื่อง

ใช้เซิร์ฟเวอร์แยกวิเคราะห์

ก่อนที่คุณจะเริ่มตรวจสอบให้แน่ใจว่าได้ติดตั้ง:

nodejs ที่มี npm
MongoDB หรือ PostgreSQL (พร้อม postgis 2.2.0 หรือสูงกว่า)
ทางเลือก Docker

ความเข้ากันได้

node.js

Parse Server ได้รับการทดสอบอย่างต่อเนื่องกับรุ่นล่าสุดของ Node.js เพื่อให้แน่ใจว่าเข้ากันได้ เราทำตามแผนการสนับสนุนระยะยาวของ Node.js และทดสอบเฉพาะเวอร์ชันที่ได้รับการสนับสนุนอย่างเป็นทางการและยังไม่ถึงวันสุดท้ายของชีวิต

รุ่น	เวอร์ชันล่าสุด	การสิ้นสุดของชีวิต	เข้ากันได้
Node.js 18	18.20.4	เมษายน 2568	✅ใช่
node.js 20	20.15.1	เมษายน 2569	✅ใช่
Node.js 22	22.4.1	เมษายน 2027	✅ใช่

MongoDB

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

รุ่น	เวอร์ชันล่าสุด	การสิ้นสุดของชีวิต	เข้ากันได้
MongoDB 4.2	4.2.25	เมษายน 2566	✅ใช่
MongoDB 4.4	4.4.29	กุมภาพันธ์ 2567	✅ใช่
MongoDB 5	5.0.26	ตุลาคม 2567	✅ใช่
MongoDB 6	6.0.14	กรกฎาคม 2025	✅ใช่
MongoDB 7	7.0.8	TDB	✅ใช่
MongoDB 8	8.0.0	TDB	✅ใช่

PostgreSQL

Parse Server ได้รับการทดสอบอย่างต่อเนื่องกับการเผยแพร่ล่าสุดของ PostgreSQL และ PostGIS เพื่อให้แน่ใจว่าเข้ากันได้โดยใช้รูปภาพ Postgis Docker เราทำตามตารางการสนับสนุน PostgreSQL และกำหนดการสนับสนุน postgis และทดสอบเฉพาะเวอร์ชันที่ได้รับการสนับสนุนอย่างเป็นทางการและยังไม่ถึงวันสุดท้ายของชีวิต เนื่องจากระยะเวลาการสนับสนุน PostgreSQL ที่กว้างขวาง 5 ปีเซิร์ฟเวอร์แยกวิเคราะห์ลดลงประมาณ 2 ปีก่อนวันสิ้นสุดชีวิตอย่างเป็นทางการ

รุ่น	เวอร์ชัน postgis	การสิ้นสุดของชีวิต	การรองรับเซิร์ฟเวอร์แยกวิเคราะห์	เข้ากันได้
Postgres 13	3.1, 3.2, 3.3, 3.4, 3.5	พฤศจิกายน 2568	<= 6.x (2023)	✅ใช่
Postgres 14	3.5	พฤศจิกายน 2569	<= 7.x (2024)	✅ใช่
Postgres 15	3.5	พฤศจิกายน 2027	<= 8.x (2025)	✅ใช่
Postgres 16	3.5	พฤศจิกายน 2028	<= 9.x (2026)	✅ใช่
Postgres 17	3.5	พฤศจิกายน 2029	<= 9.x (2026)	✅ใช่

ในระดับท้องถิ่น

$ npm install -g parse-server mongodb-runner
$ mongodb-runner start
$ parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://localhost/test

หมายเหตุ: หากการติดตั้งด้วย -g ล้มเหลวเนื่องจากปัญหาการอนุญาต ( npm ERR! code 'EACCES' ) โปรดดูลิงค์นี้

คอนเทนเนอร์ Docker

$ git clone https://github.com/parse-community/parse-server
$ cd parse-server
$ docker build --tag parse-server .
$ docker run --name my-mongo -d mongo

การรันอิมเมจเซิร์ฟเวอร์ Parse

$ docker run --name my-parse-server -v config-vol:/parse-server/config -p 1337:1337 --link my-mongo:mongo -d parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://mongo/test

หมายเหตุ: หากคุณต้องการใช้รหัสคลาวด์ให้เพิ่ม -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js ไปยังคำสั่งด้านบน ตรวจสอบให้แน่ใจว่า main.js อยู่ในไดเรกทอรี cloud-code-vol ก่อนเริ่มต้นเซิร์ฟเวอร์แยกวิเคราะห์

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

แค่ไหน! ตอนนี้คุณกำลังใช้เซิร์ฟเวอร์ Parse Server รุ่นสแตนด์อโลนบนเครื่องของคุณ

ใช้ MongoDB ระยะไกล? ผ่านพารามิเตอร์ --databaseURI DATABASE_URI เมื่อเริ่มต้น parse-server เรียนรู้เพิ่มเติมเกี่ยวกับการกำหนดค่าเซิร์ฟเวอร์ Parse ที่นี่ สำหรับรายการตัวเลือกที่มีอยู่ทั้งหมดเรียกใช้ parse-server --help

บันทึกวัตถุ

ตอนนี้คุณกำลังใช้งานเซิร์ฟเวอร์แยกวิเคราะห์ถึงเวลาที่จะบันทึกวัตถุแรกของคุณแล้ว เราจะใช้ REST API แต่คุณสามารถทำเช่นเดียวกันได้อย่างง่ายดายโดยใช้ SDK แบบแยกวิเคราะห์ใด ๆ เรียกใช้สิ่งต่อไปนี้:

$ curl -X POST 
-H " X-Parse-Application-Id: APPLICATION_ID " 
-H " Content-Type: application/json " 
-d ' {"score":1337,"playerName":"Sean Plott","cheatMode":false} ' 
http://localhost:1337/parse/classes/GameScore

คุณควรได้รับการตอบกลับคล้ายกับสิ่งนี้:

 {
  "objectId" : "2ntvSpRGIK" ,
  "createdAt" : "2016-03-11T23:51:48.050Z"
}

ตอนนี้คุณสามารถเรียกคืนวัตถุนี้ได้โดยตรง (ตรวจสอบให้แน่ใจว่าได้แทนที่ 2ntvSpRGIK ด้วย objectId จริงที่คุณได้รับเมื่อสร้างวัตถุ):

$ curl -X GET 
  -H " X-Parse-Application-Id: APPLICATION_ID " 
  http://localhost:1337/parse/classes/GameScore/2ntvSpRGIK

 // Response
{
  "objectId" : " 2ntvSpRGIK " ,
  "score" : 1337 ,
  "playerName" : " Sean Plott " ,
  "cheatMode" : false ,
  "updatedAt" : " 2016-03-11T23:51:48.050Z " ,
  "createdAt" : " 2016-03-11T23:51:48.050Z "
}

อย่างไรก็ตามการรักษาแทร็กของรหัสวัตถุแต่ละรายการนั้นไม่เหมาะ ในกรณีส่วนใหญ่คุณจะต้องเรียกใช้การสืบค้นผ่านคอลเลกชันเช่น So:

$ curl -X GET 
  -H " X-Parse-Application-Id: APPLICATION_ID " 
  http://localhost:1337/parse/classes/GameScore

 // The response will provide all the matching objects within the `results` array:
{
  "results" : [
    {
      "objectId" : " 2ntvSpRGIK " ,
      "score" : 1337 ,
      "playerName" : " Sean Plott " ,
      "cheatMode" : false ,
      "updatedAt" : " 2016-03-11T23:51:48.050Z " ,
      "createdAt" : " 2016-03-11T23:51:48.050Z "
    }
  ]
}

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการใช้การบันทึกและการสืบค้นวัตถุบนเซิร์ฟเวอร์ Parse ให้ตรวจสอบเอกสารการแยกวิเคราะห์

เชื่อมต่อ SDK

Parse ให้บริการ SDKs สำหรับแพลตฟอร์มหลักทั้งหมด อ้างถึงคู่มือ Parse Server เพื่อเรียนรู้วิธีเชื่อมต่อแอปของคุณกับ Parse Server

เรียกใช้เซิร์ฟเวอร์แยกวิเคราะห์ที่อื่น

เมื่อคุณมีความเข้าใจที่ดีขึ้นเกี่ยวกับวิธีการทำงานของโครงการโปรดดูที่เซิร์ฟเวอร์ Parse Server Wiki สำหรับคำแนะนำเชิงลึกเพื่อปรับใช้เซิร์ฟเวอร์ Parse กับผู้ให้บริการโครงสร้างพื้นฐานที่สำคัญ อ่านเพื่อเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการใช้งานเซิร์ฟเวอร์ที่แยกวิเคราะห์

แอปพลิเคชันตัวอย่าง

เราได้จัดเตรียมแอปพลิเคชัน Node.js พื้นฐานที่ใช้โมดูลเซิร์ฟเวอร์ Parse บน Express และสามารถปรับใช้กับผู้ให้บริการโครงสร้างพื้นฐานต่างๆได้อย่างง่ายดาย:

Heroku และ Mlab
AWS และ Elastic Beanstalk
เอ็นจิ้น Google App
Microsoft Azure
ซาชิโด
มหาสมุทรดิจิตอล
บริการเว็บที่สำคัญ
back4App
ความผิดพลาด
ฟลินน์
ความเอื้อเฟื้อ

Parse Server + Express

นอกจากนี้คุณยังสามารถสร้างอินสแตนซ์ของเซิร์ฟเวอร์ Parse และติดตั้งบนเว็บไซต์ Express ใหม่หรือที่มีอยู่:

 const express = require ( 'express' ) ;
const ParseServer = require ( 'parse-server' ) . ParseServer ;
const app = express ( ) ;

const server = new ParseServer ( {
  databaseURI : 'mongodb://localhost:27017/dev' , // Connection string for your MongoDB database
  cloud : './cloud/main.js' , // Path to your Cloud Code
  appId : 'myAppId' ,
  masterKey : 'myMasterKey' , // Keep this key secret!
  fileKey : 'optionalFileKey' ,
  serverURL : 'http://localhost:1337/parse' // Don't forget to change to https if needed
} ) ;

// Start server
await server . start ( ) ;

// Serve the Parse API on the /parse URL prefix
app . use ( '/parse' , server . app ) ;

app . listen ( 1337 , function ( ) {
  console . log ( 'parse-server-example running on port 1337.' ) ;
} ) ;

สำหรับรายการตัวเลือกที่มีอยู่ทั้งหมดให้เรียกใช้ parse-server --help หรือดูที่ [Parse Server Configurations] [ตัวเลือกเซิร์ฟเวอร์]

Parse Server Health

ตรวจสอบสุขภาพของเซิร์ฟเวอร์ Parse โดยส่งคำขอไปยังจุดสิ้นสุดของ /parse/health

การตอบกลับมีลักษณะเช่นนี้:

{
  "status" : " ok "
}

ค่าสถานะ

ค่า	คำอธิบาย
`initialized`	เซิร์ฟเวอร์ถูกสร้างขึ้น แต่วิธี `start` ยังไม่ได้รับการเรียก
`starting`	เซิร์ฟเวอร์เริ่มต้นขึ้น
`ok`	เซิร์ฟเวอร์เริ่มต้นและกำลังทำงานอยู่
`error`	มีข้อผิดพลาดในการเริ่มต้นดูบันทึกสำหรับรายละเอียด

การกำหนดค่า

Parse Server สามารถกำหนดค่าได้โดยใช้ตัวเลือกต่อไปนี้ คุณอาจส่งผ่านพารามิเตอร์เหล่านี้เมื่อเรียกใช้ parse-server แบบสแตนด์อโลนหรือโดยการโหลดไฟล์การกำหนดค่าในรูปแบบ JSON โดยใช้ parse-server path/to/configuration.json หากคุณใช้ Parse Server บน Express คุณอาจส่งผ่านไปยังวัตถุ ParseServer เป็นตัวเลือก

สำหรับรายการตัวเลือกที่มีอยู่ทั้งหมดให้เรียกใช้ parse-server --help หรือดูที่ [การกำหนดค่าเซิร์ฟเวอร์ Parse] [ตัวเลือกเซิร์ฟเวอร์]

ตัวเลือกพื้นฐาน

appId (จำเป็น) - Application ID เพื่อโฮสต์ด้วยอินสแตนซ์เซิร์ฟเวอร์นี้ คุณสามารถใช้สตริงโดยพลการใด ๆ สำหรับแอพย้ายถิ่นฐานสิ่งนี้ควรตรงกับแอพ Parse ที่โฮสต์ของคุณ
masterKey (จำเป็น) - คีย์หลักที่จะใช้เพื่อการรักษาความปลอดภัย ACL คุณสามารถใช้สตริงโดยพลการใด ๆ เก็บไว้เป็นความลับ! สำหรับแอพย้ายถิ่นฐานสิ่งนี้ควรตรงกับแอพ Parse ที่โฮสต์ของคุณ
databaseURI (จำเป็น) - สตริงการเชื่อมต่อสำหรับฐานข้อมูลของคุณเช่น mongodb://user:[email protected]/dbname ตรวจสอบให้แน่ใจว่า URL เข้ารหัสรหัสผ่านของคุณหากรหัสผ่านของคุณมีอักขระพิเศษ
port - พอร์ตเริ่มต้นคือ 1337 ระบุพารามิเตอร์นี้เพื่อใช้พอร์ตอื่น
serverURL - URL ไปยังเซิร์ฟเวอร์ Parse ของคุณ (อย่าลืมระบุ http: // หรือ https: //) URL นี้จะใช้เมื่อทำการร้องขอการแยกวิเคราะห์เซิร์ฟเวอร์จากรหัสคลาวด์
cloud - เส้นทางที่แน่นอนไปยังไฟล์เมน main.js ของคุณ
push - ตัวเลือกการกำหนดค่าสำหรับ APNs และ GCM Push ดูการแจ้งเตือนแบบพุชอย่างรวดเร็ว

ตัวเลือกคีย์ไคลเอนต์

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

clientKey
javascriptKey
restAPIKey
dotNetKey

เข้าถึงขอบเขต

ขอบเขต	ข้อมูลภายใน	ข้อมูลอ่านอย่างเดียว ₍₁₎	ข้อมูลที่กำหนดเอง	จำกัด โดย CLP, ACL	สำคัญ
ภายใน	r/w	r/w	r/w	เลขที่	`maintenanceKey`
ผู้เชี่ยวชาญ	-	r/-	r/w	เลขที่	`masterKey`
ReadonlyMaster	-	r/-	r/-	เลขที่	`readOnlyMasterKey`
การประชุม	-	r/-	r/w	ใช่	`sessionToken`

_{(1) Parse.Object.createdAt , Parse.Object.updatedAt}

การยืนยันอีเมลและรีเซ็ตรหัสผ่าน

การตรวจสอบที่อยู่อีเมลผู้ใช้และการเปิดใช้งานการรีเซ็ตรหัสผ่านทางอีเมลต้องใช้อะแดปเตอร์อีเมล มีอะแดปเตอร์อีเมลจำนวนมากจัดหาและดูแลโดยชุมชน ต่อไปนี้เป็นตัวอย่างการกำหนดค่าที่มีตัวอย่างอะแดปเตอร์อีเมล ดู [ตัวเลือก Parse Server] [ตัวเลือกเซิร์ฟเวอร์] สำหรับรายละเอียดเพิ่มเติมและรายการตัวเลือกที่มีอยู่ทั้งหมด

 const server = ParseServer ( {
  ... otherOptions ,

  // Enable email verification
  verifyUserEmails : true ,

  // Set email verification token validity to 2 hours
  emailVerifyTokenValidityDuration : 2 * 60 * 60 ,

  // Set email adapter
  emailAdapter : {
    module : 'example-mail-adapter' ,
    options : {
      // Additional adapter options
      ... mailAdapterOptions
    }
  } ,
} ) ;

อะแดปเตอร์อีเมลอย่างเป็นทางการดูแลโดยแพลตฟอร์ม Parse:

Parse-Server-Api-Mail-Adapter (การแปล, เทมเพลต, สนับสนุนผู้ให้บริการอีเมลในระดับสากล)

อะแดปเตอร์อีเมลที่มีส่วนร่วมโดยชุมชน:

Parse-SMTP-Template (การแปลเทมเพลต)
Parse-Server-Postmark-Adapter
Parse-Server-Sendgrid-Adapter
Parse-Server-Mandrill-Adapter
การแยกวิเคราะห์ของเซิร์ฟเวอร์
Parse-Server-Mailgun-Adapter-template
Parse-Server-Sendinblue-Adapter
Parse-Server-Mailjet-Adapter
Simple-Parse-SMTP-Adapter
Parse-Server-Generic-Email-Adapter

นโยบายรหัสผ่านและบัญชี

กำหนดรหัสผ่านและนโยบายบัญชีที่ตรงตามข้อกำหนดด้านความปลอดภัยของคุณ ต่อไปนี้เป็นตัวอย่างการกำหนดค่า ดู [ตัวเลือก Parse Server] [ตัวเลือกเซิร์ฟเวอร์] สำหรับรายละเอียดเพิ่มเติมและรายการตัวเลือกที่มีอยู่ทั้งหมด

 const server = ParseServer ( {
  ... otherOptions ,

  // The account lock policy
  accountLockout : {
    // Lock the account for 5 minutes.
    duration : 5 ,
    // Lock an account after 3 failed log-in attempts
    threshold : 3 ,
    // Unlock the account after a successful password reset
    unlockOnPasswordReset : true ,
  } ,

  // The password policy
  passwordPolicy : {
    // Enforce a password of at least 8 characters which contain at least 1 lower case, 1 upper case and 1 digit
    validatorPattern : / ^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,}) / ,
    // Do not allow the username as part of the password
    doNotAllowUsername : true ,
    // Do not allow to re-use the last 5 passwords when setting a new password
    maxPasswordHistory : 5 ,
  } ,
} ) ;

เส้นทางที่กำหนดเอง

ข้อควรระวังนี่เป็นคุณสมบัติการทดลองที่อาจไม่เหมาะสมสำหรับการผลิต

เส้นทางที่กำหนดเองอนุญาตให้สร้างการไหลของผู้ใช้ด้วยหน้าเว็บคล้ายกับการรีเซ็ตรหัสผ่านที่มีอยู่และคุณสมบัติการตรวจสอบอีเมล เส้นทางที่กำหนดเองถูกกำหนดด้วยตัวเลือก pages ในการกำหนดค่าเซิร์ฟเวอร์ Parse:

ตัวอย่าง

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for custom routes
    customRoutes : [ {
      method : 'GET' ,
      path : 'custom_route' ,
      handler : async request => {
        // custom logic
        // ...
        // then, depending on the outcome, return a HTML file as response
        return { file : 'custom_page.html' } ;
      }
    } ]
  }
}

เส้นทางข้างต้นสามารถเรียกใช้โดยส่ง GET ขอรับไปที่: https://[parseServerPublicUrl]/[parseMount]/[pagesEndpoint]/[appId]/[customRoute]

handler ได้รับ request และส่งคืนเว็บเพจ custom_page.html จากหน้าไดเรกทอรี pages.pagesPath เป็นการตอบสนอง ข้อได้เปรียบของการสร้างเส้นทางที่กำหนดเองด้วยวิธีนี้คือการใช้ความสามารถในตัวของเซิร์ฟเวอร์ Parse โดยอัตโนมัติเช่นการแปลหน้าและตัวยึดตำแหน่งแบบไดนามิก

เส้นทางที่สงวนไว้

พา ธ ต่อไปนี้ใช้งานโดยคุณสมบัติในตัวของ Parse Server และดังนั้นจึงไม่พร้อมใช้งานสำหรับเส้นทางที่กำหนดเอง เส้นทางที่กำหนดเองด้วยการรวมกันของ path และ method ที่เหมือนกันจะถูกละเว้น

เส้นทาง	วิธี http	คุณสมบัติ
`verify_email`	`GET`	การยืนยันอีเมล
`resend_verification_email`	`POST`	การยืนยันอีเมล
`choose_password`	`GET`	รีเซ็ตรหัสผ่าน
`request_password_reset`	`GET`	รีเซ็ตรหัสผ่าน
`request_password_reset`	`POST`	รีเซ็ตรหัสผ่าน

พารามิเตอร์

พารามิเตอร์	ไม่จำเป็น	พิมพ์	ค่าเริ่มต้น	ค่าตัวอย่าง	ตัวแปรสภาพแวดล้อม	คำอธิบาย
`pages`	ใช่	`Object`	`undefined`	-	`PARSE_SERVER_PAGES`	ตัวเลือกสำหรับหน้าเช่นการรีเซ็ตรหัสผ่านและการตรวจสอบอีเมล
`pages.enableRouter`	ใช่	`Boolean`	`false`	-	`PARSE_SERVER_PAGES_ENABLE_ROUTER`	เป็น `true` หากควรเปิดใช้งานเราเตอร์หน้า สิ่งนี้จำเป็นสำหรับตัวเลือกหน้าใด ๆ ที่จะมีผล ข้อควรระวังนี่เป็นคุณสมบัติการทดลองที่อาจไม่เหมาะสมสำหรับการผลิต
`pages.customRoutes`	ใช่	`Array`	`[]`	-	`PARSE_SERVER_PAGES_CUSTOM_ROUTES`	เส้นทางที่กำหนดเอง เส้นทางจะถูกเพิ่มตามลำดับที่กำหนดไว้ที่นี่ซึ่งจะต้องพิจารณาตั้งแต่คำขอเส้นทางการสำรวจเส้นทางในลักษณะที่สั่งซื้อ เส้นทางที่กำหนดเองจะถูกสำรวจหลังจากเส้นทางการสร้างเช่นรีเซ็ตรหัสผ่านและการตรวจสอบอีเมล
`pages.customRoutes.method`		`String`	-	`GET` `POST`	-	วิธี HTTP ของเส้นทางที่กำหนดเอง
`pages.customRoutes.path`		`String`	-	`custom_page`	-	เส้นทางของเส้นทางที่กำหนดเอง โปรดทราบว่าเส้นทางเดียวกันสามารถใช้งานได้หาก `method` แตกต่างกันเช่น PATH `custom_page` สามารถมีสองเส้นทางคือเส้นทาง `GET` และ `POST` ซึ่งจะถูกเรียกใช้ขึ้นอยู่กับวิธีการร้องขอ HTTP
`pages.customRoutes.handler`		`AsyncFunction`	-	`async () => { ... }`	-	ตัวจัดการเส้นทางที่ถูกเรียกใช้เมื่อเส้นทางตรงกับคำขอ HTTP หากตัวจัดการไม่ส่งคืนหน้าคำขอจะถูกตอบโดย `Not found.` 404 การตอบสนอง.

หน้ากำหนดเอง

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

 const server = ParseServer ( {
  ... otherOptions ,

  customPages : {
    passwordResetSuccess : "http://yourapp.com/passwordResetSuccess" ,
    verifyEmailSuccess : "http://yourapp.com/verifyEmailSuccess" ,
    parseFrameURL : "http://yourapp.com/parseFrameURL" ,
    linkSendSuccess : "http://yourapp.com/linkSendSuccess" ,
    linkSendFail : "http://yourapp.com/linkSendFail" ,
    invalidLink : "http://yourapp.com/invalidLink" ,
    invalidVerificationLink : "http://yourapp.com/invalidVerificationLink" ,
    choosePassword : "http://yourapp.com/choosePassword"
  }
} )

การใช้ตัวแปรสภาพแวดล้อม

คุณสามารถกำหนดค่าเซิร์ฟเวอร์ Parse โดยใช้ตัวแปรสภาพแวดล้อม:

PORT
PARSE_SERVER_APPLICATION_ID
PARSE_SERVER_MASTER_KEY
PARSE_SERVER_DATABASE_URI
PARSE_SERVER_URL
PARSE_SERVER_CLOUD

พอร์ตเริ่มต้นคือ 1337 เพื่อใช้พอร์ตอื่นตั้งค่าตัวแปรสภาพแวดล้อมพอร์ต:

$ PORT=8080 parse-server --appId APPLICATION_ID --masterKey MASTER_KEY

สำหรับรายการทั้งหมดของตัวแปรสภาพแวดล้อมที่กำหนดค่าได้ให้เรียกใช้ parse-server --help หรือดูการกำหนดค่าเซิร์ฟเวอร์ที่แยกวิเคราะห์

อะแดปเตอร์ที่มีอยู่

อะแดปเตอร์อย่างเป็นทางการทั้งหมดมีการแจกจ่ายเป็นแพ็คเกจที่กำหนดขอบเขตบน NPM (@Parse)

อะแดปเตอร์ที่ได้รับการดูแลอย่างดีบางตัวยังมีอยู่ในองค์กร Parse Server Modules

นอกจากนี้คุณยังสามารถค้นหาอะแดปเตอร์เพิ่มเติมที่ดูแลโดยชุมชนโดยการค้นหาใน NPM

การกำหนดค่าอะแดปเตอร์ไฟล์

Parse Server อนุญาตให้นักพัฒนาเลือกจากตัวเลือกหลายตัวเมื่อโฮสต์ไฟล์:

GridFSBucketAdapter - ซึ่งได้รับการสนับสนุนจาก MongoDB
S3Adapter - ซึ่งได้รับการสนับสนุนจาก Amazon S3
GCSAdapter - ซึ่งได้รับการสนับสนุนจาก Google Cloud Storage
FSAdapter - ที่เก็บไฟล์ท้องถิ่น

GridFSBucketAdapter ใช้โดยค่าเริ่มต้นและไม่จำเป็นต้องตั้งค่า แต่หากคุณสนใจที่จะใช้ Amazon S3, Google Cloud Storage หรือที่เก็บไฟล์ในท้องถิ่นข้อมูลการกำหนดค่าเพิ่มเติมจะมีอยู่ในคู่มือเซิร์ฟเวอร์ Parse

การบังคับใช้ idempotency

ข้อควรระวังนี่เป็นคุณสมบัติการทดลองที่อาจไม่เหมาะสมสำหรับการผลิต

คุณลักษณะนี้ได้รับการตอบสนองที่เหมือนกันซึ่งได้รับจาก Parse Server หลายครั้งโดยทั่วไปเนื่องจากปัญหาเครือข่ายหรือข้อ จำกัด การเข้าถึงอะแดปเตอร์เครือข่ายในระบบปฏิบัติการมือถือ

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

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

การเจรจาซ้ำ ๆ จะทำเพื่อการสร้างวัตถุและการอัปเดต ( POST และ PUT คำขอ) การขจัดข้อมูลซ้ำซ้อนไม่ได้ทำเพื่อค้นหาและลบวัตถุ ( GET และ DELETE คำขอ) เนื่องจากการดำเนินการเหล่านี้มีอยู่แล้วตามคำจำกัดความ

ตัวอย่างการกำหนดค่า

 let api = new ParseServer({
    idempotencyOptions: {
        paths: [".*"],       // enforce for all requests
        ttl: 120             // keep request IDs for 120s
    }
}

พารามิเตอร์

พารามิเตอร์	ไม่จำเป็น	พิมพ์	ค่าเริ่มต้น	ค่าตัวอย่าง	ตัวแปรสภาพแวดล้อม	คำอธิบาย
`idempotencyOptions`	ใช่	`Object`	`undefined`		parse_server_experimental_idempotency_options	การตั้งค่านี้ช่วยให้การบังคับใช้ idempotency สำหรับเส้นทางที่ระบุ
`idempotencyOptions.paths`	ใช่	`Array<String>`	`[]`	`.` (เส้นทางทั้งหมดรวมถึงตัวอย่างด้านล่าง) `functions/.` (ฟังก์ชั่นทั้งหมด) `jobs/.` (งานทั้งหมด), `classes/.` (ทุกคลาส), `functions/.*` (ฟังก์ชั่นทั้งหมด) `users` (การสร้าง / อัปเดตผู้ใช้) `installations` (การสร้างการติดตั้ง / อัปเดต)	parse_server_experimental_idempotency_paths	อาร์เรย์ของรูปแบบเส้นทางที่ต้องจับคู่เส้นทางคำขอสำหรับการขอซ้ำการขอซ้ำที่จะเปิดใช้งาน ต้องไม่รวมเส้นทางการเมานต์ตัวอย่างเช่นเพื่อให้ตรงกับเส้นทางการร้องขอ `/parse/functions/myFunction` ระบุ `functions/myFunction` สแลชต่อท้ายของเส้นทางคำขอจะถูกละเว้นตัวอย่างเช่น `functions/myFunction` ตรงกับทั้ง `/parse/functions/myFunction` และ `/parse/functions/myFunction/`
`idempotencyOptions.ttl`	ใช่	`Integer`	`300`	`60` (60 วินาที)	parse_server_experimental_idempotency_ttl	ระยะเวลาในวินาทีหลังจากนั้นบันทึกการร้องขอจะถูกยกเลิกจากฐานข้อมูล คำขอที่ซ้ำกันเนื่องจากปัญหาเครือข่ายสามารถคาดว่าจะมาถึงภายในมิลลิวินาทีถึงหลายวินาที ค่านี้จะต้องมากกว่า `0`

Postgres

ในการใช้คุณสมบัตินี้ใน Postgres คุณจะต้องสร้างงาน cron โดยใช้ pGADMIN หรือคล้ายกับการเรียกใช้ฟังก์ชัน postgres idempotency_delete_expired_records() ที่ลบบันทึก idempotency ที่หมดอายุ คุณสามารถค้นหาสคริปต์ตัวอย่างด้านล่าง ตรวจสอบให้แน่ใจว่าสคริปต์มีสิทธิ์เหมือนกันในการลงชื่อเข้าใช้ postgres เป็นเซิร์ฟเวอร์แยกวิเคราะห์

 #! /bin/bash

set -e
psql -v ON_ERROR_STOP=1 --username " $POSTGRES_USER " --dbname " $POSTGRES_DB " << - EOSQL
    SELECT idempotency_delete_expired_records();
EOSQL

exec " $@ "

สมมติว่าสคริปต์ด้านบนมีชื่อชื่อ parse_idempotency_delete_expired_records.sh , งาน cron ที่ทำงานสคริปต์ทุก 2 นาทีอาจดูเหมือน:

2 * * * * /root/parse_idempotency_delete_expired_records.sh > /dev/null 2>&1

การแปลเป็นภาษาท้องถิ่น

หน้า

ข้อควรระวังนี่เป็นคุณสมบัติการทดลองที่อาจไม่เหมาะสมสำหรับการผลิต

หน้าแบบกำหนดเองรวมถึงหน้าคุณสมบัติ (เช่นการรีเซ็ตรหัสผ่านการตรวจสอบอีเมล) สามารถแปลได้ด้วยตัวเลือก pages ในการกำหนดค่าเซิร์ฟเวอร์ Parse:

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for localization
    enableLocalization : true ,
  }
}

การแปลสามารถทำได้โดยการจับคู่พารามิเตอร์ locale ที่จัดหาที่จัดหากับเนื้อหาหน้าเว็บที่แปลเป็นภาษาท้องถิ่น สถานที่สามารถจัดหาได้ทั้งในแบบสอบถามคำขอร่างกายหรือส่วนหัวด้วยคีย์ต่อไปนี้:

แบบสอบถาม: locale
ร่างกาย: locale
ส่วนหัว: x-parse-page-param-locale

ตัวอย่างเช่นลิงค์รีเซ็ตรหัสผ่านพร้อมพารามิเตอร์โลคัลในแบบสอบถามอาจมีลักษณะเช่นนี้:

 http://example.com/parse/apps/[appId]/request_password_reset?token=[token]&username=[username]&locale=de-AT

การแปลมีให้เฉพาะสำหรับหน้าในไดเรกทอรีหน้าตามที่กำหนดไว้กับ pages.pagesPath
การแปลสำหรับหน้าคุณสมบัติ (เช่นการรีเซ็ตรหัสผ่านการตรวจสอบอีเมล) จะถูกปิดใช้งานหากมีการตั้งค่า pages.customUrls แม้ว่า URL ที่กำหนดเองจะชี้ไปที่หน้าภายในเส้นทางหน้า
เฉพาะไฟล์ .html เท่านั้นที่ได้รับการพิจารณาสำหรับการแปลเมื่อ จำกัด หน้าแบบกำหนดเอง

หน้าสามารถแปลได้สองวิธี:

การแปลด้วยโครงสร้างไดเรกทอรี

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

ตัวอย่างโครงสร้างไดเรกทอรี:

 root /
├── public /                  // pages base path
│   ├── example . html         // default file
│   └── de /                  // de language folder
│   │   └── example . html     // de localized file
│   └── de - AT /               // de-AT locale folder
│   │   └── example . html     // de-AT localized file

ไฟล์ถูกจับคู่กับสถานที่ในลำดับต่อไปนี้:

การจับคู่ในสถานที่เช่น locale de-AT matches ไฟล์ในโฟลเดอร์ de-AT
การจับคู่ภาษาเช่น locale de-CH จับคู่ไฟล์ในโฟลเดอร์ de
ค่าเริ่มต้น; ไฟล์ในโฟลเดอร์ฐานจะถูกส่งกลับ

ตัวอย่างการกำหนดค่า:

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for localization
    enableLocalization : true ,
    customUrls : {
      passwordReset : 'https://example.com/page.html'
    }
  }
}

ข้อดี:

ไฟล์ทั้งหมดสมบูรณ์ในเนื้อหาของพวกเขาและสามารถเปิดและดูตัวอย่างได้อย่างง่ายดายโดยการดูไฟล์ในเบราว์เซอร์

จุดด้อย:

ในกรณีส่วนใหญ่หน้าแปลจะแตกต่างกันเพียงเล็กน้อยจากหน้าเริ่มต้นซึ่งอาจทำให้รหัสซ้ำซ้อนจำนวนมากที่ยากต่อการบำรุงรักษา

การแปลด้วยทรัพยากร JSON

หน้ามีการแปลเป็นภาษาท้องถิ่นโดยการเพิ่มตัวยึดตำแหน่งในไฟล์ HTML และจัดหาทรัพยากร JSON ที่มีการแปลเพื่อเติมเข้ากับตัวยึดตำแหน่ง

ตัวอย่างโครงสร้างไดเรกทอรี:

 root /
├── public /                  // pages base path
│   ├── example . html         // the page containing placeholders
├── private /                 // folder outside of public scope
│   └── translations . json    // JSON resource file

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

ตัวอย่างเนื้อหา JSON:

{
  "en" : {               // resource for language `en` (English)
    "translation" : {
      "greeting" : " Hello! "
    }
  },
  "de" : {               // resource for language `de` (German)
    "translation" : {
      "greeting" : " Hallo! "
    }
  }
  "de-AT" : {            // resource for locale `de-AT` (Austrian German)
    "translation" : {
      "greeting" : " Servus! "
    }
  }
}

ตัวอย่างการกำหนดค่า:

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for localization
    enableLocalization : true ,
    localizationJsonPath : './private/localization.json' ,
    localizationFallbackLocale : 'en'
  }
}

ข้อดี:

มีไฟล์ HTML เพียงไฟล์เดียวเท่านั้นที่จะรักษาที่มีตัวยึดตำแหน่งที่เต็มไปด้วยการแปลตามสถานที่

จุดด้อย:

ไฟล์ไม่สามารถดูตัวอย่างได้อย่างง่ายดายโดยการดูไฟล์ในเบราว์เซอร์เนื่องจากเนื้อหามีเพียงตัวยึดตำแหน่งและแม้แต่การเปลี่ยนแปลง HTML หรือ CSS อาจถูกนำไปใช้แบบไดนามิกเช่นเมื่อการแปลต้องการทิศทางการจัดวางขวาไปซ้าย
สไตล์และการเปลี่ยนแปลงเค้าโครงพื้นฐานอื่น ๆ อาจใช้งานได้ยากกว่า

ตัวยึดตำแหน่งแบบไดนามิก

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

ตัวอย่างการกำหนดค่า:

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for localization
    placeholders : {
      exampleKey : 'exampleValue'
    }
  }
}

ตัวยึดตำแหน่งยังสามารถให้เป็นฟังก์ชันหรือฟังก์ชั่น async ด้วย locale และพารามิเตอร์ที่เกี่ยวข้องกับคุณสมบัติอื่น ๆ ที่ผ่านเพื่อให้ค่าตัวยึดตำแหน่งแบบไดนามิก:

 const api = new ParseServer ( {
  ... otherOptions ,

  pages : {
    enableRouter : true , // Enables the experimental feature; required for localization
    placeholders : async ( params ) => {
      const value = await doSomething ( params . locale ) ;
      return {
        exampleKey : value
      } ;
    }
  }
}

คีย์ที่สงวนไว้

คีย์พารามิเตอร์และตัวยึดตำแหน่งต่อไปนี้สงวนไว้เนื่องจากมีการใช้เกี่ยวข้องกับคุณสมบัติเช่นการรีเซ็ตรหัสผ่านหรือการตรวจสอบอีเมล พวกเขาไม่ควรใช้เป็นปุ่มแปลในทรัพยากร JSON หรือเป็นปุ่มตัวยึดตำแหน่งที่กำหนดด้วยตนเองในการกำหนดค่า: appId , appName , email , error , สถานที่, locale , publicServerUrl , token , username

พารามิเตอร์

พารามิเตอร์	ไม่จำเป็น	พิมพ์	ค่าเริ่มต้น	ค่าตัวอย่าง	ตัวแปรสภาพแวดล้อม	คำอธิบาย
`pages`	ใช่	`Object`	`undefined`	-	`PARSE_SERVER_PAGES`	ตัวเลือกสำหรับหน้าเช่นการรีเซ็ตรหัสผ่านและการตรวจสอบอีเมล
`pages.enableRouter`	ใช่	`Boolean`	`false`	-	`PARSE_SERVER_PAGES_ENABLE_ROUTER`	เป็น `true` หากควรเปิดใช้งานเราเตอร์หน้า สิ่งนี้จำเป็นสำหรับตัวเลือกหน้าใด ๆ ที่จะมีผล ข้อควรระวังนี่เป็นคุณสมบัติการทดลองที่อาจไม่เหมาะสมสำหรับการผลิต
`pages.enableLocalization`	ใช่	`Boolean`	`false`	-	`PARSE_SERVER_PAGES_ENABLE_LOCALIZATION`	เป็นจริงถ้าหน้าควรมีการแปล สิ่งนี้ไม่มีผลต่อการเปลี่ยนเส้นทางหน้าแบบกำหนดเอง
`pages.localizationJsonPath`	ใช่	`String`	`undefined`	`./private/translations.json`	`PARSE_SERVER_PAGES_LOCALIZATION_JSON_PATH`	เส้นทางไปยังไฟล์ JSON สำหรับการแปล การแปลจะถูกใช้เพื่อเติมเทมเพลตตัวยึดตามสถานที่
`pages.localizationFallbackLocale`	ใช่	`String`	`en`	`en` , `en-GB` , `default`	`PARSE_SERVER_PAGES_LOCALIZATION_FALLBACK_LOCALE`	สถานที่ทางเลือกสำหรับการแปลหากไม่มีการแปลที่ตรงกันสำหรับสถานที่ที่กำหนด สิ่งนี้มีความเกี่ยวข้องเฉพาะเมื่อให้ทรัพยากรการแปลผ่านไฟล์ JSON
`pages.placeholders`	ใช่	`Object` , `Function` , `AsyncFunction`	`undefined`	`{ exampleKey: 'exampleValue' }`	`PARSE_SERVER_PAGES_PLACEHOLDERS`	คีย์และค่าของตัวยึดตำแหน่งซึ่งจะถูกเติมในหน้า; นี่อาจเป็นวัตถุง่ายๆหรือฟังก์ชั่นการโทรกลับ
`pages.forceRedirect`	ใช่	`Boolean`	`false`	-	`PARSE_SERVER_PAGES_FORCE_REDIRECT`	เป็น `true` หากการตอบกลับควรเปลี่ยนเส้นทางและไม่เคยเนื้อหา `false` หากประเภทการตอบกลับควรขึ้นอยู่กับประเภทคำขอ ( `GET` คำขอ -> การตอบสนองเนื้อหา; คำขอ `POST` -> การตอบกลับการเปลี่ยนเส้นทาง)
`pages.pagesPath`	ใช่	`String`	`./public`	`./files/pages` , `../../pages`	`PARSE_SERVER_PAGES_PAGES_PATH`	เส้นทางไปยังไดเรกทอรีหน้า นอกจากนี้ยังกำหนดตำแหน่งที่จุดสิ้นสุด `/apps` แบบคงที่ชี้ไปที่
`pages.pagesEndpoint`	ใช่	`String`	`apps`	-	`PARSE_SERVER_PAGES_PAGES_ENDPOINT`	จุดสิ้นสุด API สำหรับหน้า
`pages.customUrls`	ใช่	`Object`	`{}`	`{ passwordReset: 'https://example.com/page.html' }`	`PARSE_SERVER_PAGES_CUSTOM_URLS`	URL ไปยังหน้าแบบกำหนดเอง
`pages.customUrls.passwordReset`	ใช่	`String`	`password_reset.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET`	URL ไปยังหน้ากำหนดเองสำหรับการรีเซ็ตรหัสผ่าน
`pages.customUrls.passwordResetSuccess`	ใช่	`String`	`password_reset_success.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_SUCCESS`	URL ไปยังหน้ากำหนดเองสำหรับการรีเซ็ตรหัสผ่าน -> ความสำเร็จ
`pages.customUrls.passwordResetLinkInvalid`	ใช่	`String`	`password_reset_link_invalid.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_LINK_INVALID`	URL ไปยังหน้ากำหนดเองสำหรับการรีเซ็ตรหัสผ่าน -> ลิงก์ไม่ถูกต้อง
`pages.customUrls.emailVerificationSuccess`	ใช่	`String`	`email_verification_success.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SUCCESS`	URL ไปยังหน้ากำหนดเองสำหรับการตรวจสอบอีเมล -> ความสำเร็จ
`pages.customUrls.emailVerificationSendFail`	ใช่	`String`	`email_verification_send_fail.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_FAIL`	URL ไปยังหน้ากำหนดเองสำหรับการตรวจสอบอีเมล -> ลิงค์ส่งล้มเหลว
`pages.customUrls.emailVerificationSendSuccess`	ใช่	`String`	`email_verification_send_success.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_SUCCESS`	URL ไปยังหน้ากำหนดเองสำหรับการตรวจสอบอีเมล -> ลิงค์ส่งต่อ -> ความสำเร็จ
`pages.customUrls.emailVerificationLinkInvalid`	ใช่	`String`	`email_verification_link_invalid.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_INVALID`	URL ไปยังหน้ากำหนดเองสำหรับการตรวจสอบอีเมล -> ลิงก์ไม่ถูกต้อง
`pages.customUrls.emailVerificationLinkExpired`	ใช่	`String`	`email_verification_link_expired.html`	-	`PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_EXPIRED`	URL ไปยังหน้ากำหนดเองสำหรับการตรวจสอบอีเมล -> ลิงก์หมดอายุ

หมายเหตุ

ร่วมกับเซิร์ฟเวอร์ Parse Mail Parse Server Parse Mail Server ให้โฟลว์ที่มีการแปลอย่างสมบูรณ์ (อีเมล -> หน้า) สำหรับผู้ใช้ อะแดปเตอร์อีเมลจะส่งอีเมลที่แปลเป็นภาษาท้องถิ่นและเพิ่มพารามิเตอร์โลคาลไปยังลิงค์รีเซ็ตรหัสผ่านหรือลิงก์การยืนยันอีเมลซึ่งจะใช้เพื่อตอบกลับด้วยหน้าเว็บที่มีการแปล

การตัดไม้

Parse Server จะเป็นค่าเริ่มต้นบันทึก:

ไปยังคอนโซล
ไฟล์หมุนรายวันเป็นบรรทัดใหม่ที่คั่นด้วย JSON

บันทึกสามารถดูได้ในแผงควบคุม

ต้องการบันทึกคำขอและการตอบกลับแต่ละครั้งหรือไม่? ตั้งค่าตัวแปรสภาพแวดล้อม VERBOSE เมื่อเริ่มต้น parse-server การใช้งาน: VERBOSE='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY

ต้องการบันทึกไว้ในโฟลเดอร์อื่นหรือไม่? ผ่านตัวแปรสภาพแวดล้อม PARSE_SERVER_LOGS_FOLDER เมื่อเริ่มต้น parse-server การใช้งาน: PARSE_SERVER_LOGS_FOLDER='<path-to-logs-folder>' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY

ต้องการบันทึกระดับเฉพาะหรือไม่? ผ่านพารามิเตอร์ logLevel เมื่อเริ่มต้น parse-server การใช้งาน: parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --logLevel LOG_LEVEL

ต้องการบันทึกข้อผิดพลาด JSON ที่คั่นด้วยบรรทัดใหม่ (สำหรับการบริโภคโดย CloudWatch, Google Cloud Logging ฯลฯ ) หรือไม่? ผ่านตัวแปรสภาพแวดล้อม JSON_LOGS เมื่อเริ่มต้น parse-server การใช้งาน: JSON_LOGS='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY

การคัดค้าน

ดูแผนการเสื่อมราคาสำหรับภาพรวมของการคัดค้านและการเปลี่ยนแปลงที่วางแผนไว้

แบบสอบถามสด

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

ดูคู่มือการสืบค้นสดคู่มือการตั้งค่าเซิร์ฟเวอร์แบบสอบถามสดและข้อมูลจำเพาะโปรโตคอลการสืบค้นสด คุณสามารถตั้งค่าเซิร์ฟเวอร์แบบสแตนด์อโลนหรือหลายอินสแตนซ์เพื่อความสามารถในการปรับขนาด (แนะนำ)

graphql

GraphQL พัฒนาโดย Facebook เป็นแบบสอบถามข้อมูลโอเพนซอร์ซและภาษาการจัดการสำหรับ API นอกเหนือจาก REST API แบบดั้งเดิมแล้ว Parse Server จะสร้าง GraphQL API โดยอัตโนมัติตามสคีมาแอปพลิเคชันปัจจุบันของคุณ Parse Server ยังช่วยให้คุณสามารถกำหนดคิวรีและการกลายพันธุ์ของ GraphQL ที่กำหนดเองได้ซึ่งผู้แก้ไขสามารถผูกมัดกับฟังก์ชั่นรหัสคลาวด์ของคุณได้

วิ่ง

ใช้ CLI

วิธีที่ง่ายที่สุดในการเรียกใช้ Parse GraphQL API คือผ่าน CLI:

$ npm install -g parse-server mongodb-runner
$ mongodb-runner start
$ parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://localhost/test --publicServerURL http://localhost:1337/parse --mountGraphQL --mountPlayground

หลังจากเริ่มต้นเซิร์ฟเวอร์คุณสามารถเยี่ยมชม http: // localhost: 1337/สนามเด็กเล่นในเบราว์เซอร์ของคุณเพื่อเริ่มเล่นกับ GraphQL API ของคุณ

หมายเหตุ: อย่า ใช้ -ตัวเลือก Mountplayground ในการผลิต Parse Dashboard มีสนามเด็กเล่น GraphQL ในตัวและเป็นตัวเลือกที่แนะนำสำหรับแอพการผลิต

ใช้นักเทียบท่า

คุณยังสามารถเรียกใช้ Parse GraphQL API ภายในคอนเทนเนอร์ Docker:

$ git clone https://github.com/parse-community/parse-server
$ cd parse-server
$ docker build --tag parse-server .
$ docker run --name my-mongo -d mongo

การรันอิมเมจเซิร์ฟเวอร์ Parse

$ docker run --name my-parse-server --link my-mongo:mongo -v config-vol:/parse-server/config -p 1337:1337 -d parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://mongo/test --publicServerURL http://localhost:1337/parse --mountGraphQL --mountPlayground

ใช้ Express.js

นอกจากนี้คุณยังสามารถติดตั้ง GraphQL API ในแอปพลิเคชัน Express.js พร้อมกับ REST API หรือ Solo ก่อนอื่นคุณต้องสร้างโครงการใหม่และติดตั้งการอ้างอิงที่ต้องการ:

$ mkdir my-app
$ cd my-app
$ npm install parse-server express --save

จากนั้นสร้างไฟล์ index.js ด้วยเนื้อหาต่อไปนี้:

 const express = require ( 'express' ) ;
const { ParseServer , ParseGraphQLServer } = require ( 'parse-server' ) ;

const app = express ( ) ;

const parseServer = new ParseServer ( {
  databaseURI : 'mongodb://localhost:27017/test' ,
  appId : 'APPLICATION_ID' ,
  masterKey : 'MASTER_KEY' ,
  serverURL : 'http://localhost:1337/parse' ,
  publicServerURL : 'http://localhost:1337/parse'
} ) ;

const parseGraphQLServer = new ParseGraphQLServer (
  parseServer ,
  {
    graphQLPath : '/graphql' ,
    playgroundPath : '/playground'
  }
) ;

app . use ( '/parse' , parseServer . app ) ; // (Optional) Mounts the REST API
parseGraphQLServer . applyGraphQL ( app ) ; // Mounts the GraphQL API
parseGraphQLServer . applyPlayground ( app ) ; // (Optional) Mounts the GraphQL Playground - do NOT use in Production

await parseServer . start ( ) ;
app . listen ( 1337 , function ( ) {
  console . log ( 'REST API running on http://localhost:1337/parse' ) ;
  console . log ( 'GraphQL API running on http://localhost:1337/graphql' ) ;
  console . log ( 'GraphQL Playground running on http://localhost:1337/playground' ) ;
} ) ;

และในที่สุดก็เริ่มแอปของคุณ:

$ npx mongodb-runner start
$ node index.js

หลังจากเริ่มแอพคุณสามารถเยี่ยมชม http: // localhost: 1337/สนามเด็กเล่นในเบราว์เซอร์ของคุณเพื่อเริ่มเล่นกับ GraphQL API ของคุณ

หมายเหตุ: อย่า ติดตั้งสนามเด็กเล่น GraphQL ในการผลิต Parse Dashboard มีสนามเด็กเล่น GraphQL ในตัวและเป็นตัวเลือกที่แนะนำสำหรับแอพการผลิต

ตรวจสอบสุขภาพของ API

เรียกใช้สิ่งต่อไปนี้:

 query Health {
  health
}

คุณควรได้รับคำตอบต่อไปนี้:

{
  "data" : {
    "health" : true
  }
}

การสร้างชั้นหนึ่งของคุณ

เนื่องจากแอปพลิเคชันของคุณยังไม่มีสคีมาคุณสามารถใช้การกลายพันธุ์ createClass เพื่อสร้างคลาสแรกของคุณ เรียกใช้สิ่งต่อไปนี้:

 mutation CreateClass {
  createClass (
    name : " GameScore "
    schemaFields : {
      addStrings : [{ name : " playerName " }]
      addNumbers : [{ name : " score " }]
      addBooleans : [{ name : " cheatMode " }]
    }
  ) {
    name
    schemaFields {
      name
      __typename
    }
  }
}

คุณควรได้รับคำตอบต่อไปนี้:

{
  "data" : {
    "createClass" : {
      "name" : " GameScore " ,
      "schemaFields" : [
        {
          "name" : " objectId " ,
          "__typename" : " SchemaStringField "
        },
        {
          "name" : " updatedAt " ,
          "__typename" : " SchemaDateField "
        },
        {
          "name" : " createdAt " ,
          "__typename" : " SchemaDateField "
        },
        {
          "name" : " playerName " ,
          "__typename" : " SchemaStringField "
        },
        {
          "name" : " score " ,
          "__typename" : " SchemaNumberField "
        },
        {
          "name" : " cheatMode " ,
          "__typename" : " SchemaBooleanField "
        },
        {
          "name" : " ACL " ,
          "__typename" : " SchemaACLField "
        }
      ]
    }
  }
}

ใช้การดำเนินการที่สร้างขึ้นโดยอัตโนมัติ

Parse Server เรียนรู้จากคลาสแรกที่คุณสร้างขึ้นและตอนนี้คุณมีคลาส GameScore ในสคีมาของคุณ ตอนนี้คุณสามารถเริ่มใช้การดำเนินการที่สร้างขึ้นโดยอัตโนมัติ!

เรียกใช้สิ่งต่อไปนี้เพื่อสร้างวัตถุแรกของคุณ:

 mutation CreateGameScore {
  createGameScore (
    fields : {
      playerName : " Sean Plott "
      score : 1337
      cheatMode : false
    }
  ) {
    id
    updatedAt
    createdAt
    playerName
    score
    cheatMode
    ACL
  }
}

คุณควรได้รับการตอบกลับคล้ายกับสิ่งนี้:

{
  "data" : {
    "createGameScore" : {
      "id" : " XN75D94OBD " ,
      "updatedAt" : " 2019-09-17T06:50:26.357Z " ,
      "createdAt" : " 2019-09-17T06:50:26.357Z " ,
      "playerName" : " Sean Plott " ,
      "score" : 1337 ,
      "cheatMode" : false ,
      "ACL" : null
    }
  }
}

นอกจากนี้คุณยังสามารถเรียกใช้แบบสอบถามไปยังคลาสใหม่นี้:

 query GameScores {
  gameScores {
    results {
      id
      updatedAt
      createdAt
      playerName
      score
      cheatMode
      ACL
    }
  }
}

คุณควรได้รับการตอบกลับคล้ายกับสิ่งนี้:

{
  "data" : {
    "gameScores" : {
      "results" : [
        {
          "id" : " XN75D94OBD " ,
          "updatedAt" : " 2019-09-17T06:50:26.357Z " ,
          "createdAt" : " 2019-09-17T06:50:26.357Z " ,
          "playerName" : " Sean Plott " ,
          "score" : 1337 ,
          "cheatMode" : false ,
          "ACL" : null
        }
      ]
    }
  }
}

ปรับแต่ง schema graphql ของคุณ

Parse GraphQl Server ช่วยให้คุณสร้าง schema graphql ที่กำหนดเองด้วยการสืบค้นและการกลายพันธุ์ของตัวเองเพื่อรวมเข้ากับแบบที่สร้างอัตโนมัติ คุณสามารถแก้ไขการดำเนินการเหล่านี้โดยใช้ฟังก์ชั่นรหัสคลาวด์ปกติของคุณ

ในการเริ่มต้นสร้างสคีมาที่กำหนดเองของคุณคุณจะต้องใช้รหัสไฟล์ schema.graphql และเริ่มต้นเซิร์ฟเวอร์การแยกวิเคราะห์ด้วย --graphQLSchema และ --cloud ตัวเลือกคลาวด์:

$ parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://localhost/test --publicServerURL http://localhost:1337/parse --cloud ./cloud/main.js --graphQLSchema ./cloud/schema.graphql --mountGraphQL --mountPlayground

การสร้างแบบสอบถามที่กำหนดเองครั้งแรกของคุณ

ใช้รหัสด้านล่างสำหรับไฟล์ schema.graphql และ main.js ของคุณ จากนั้นรีสตาร์ทเซิร์ฟเวอร์แยกวิเคราะห์ของคุณ

 # schema.graphql
extend type Query {
  hello : String ! @resolve
}

 // main.js
Parse . Cloud . define ( 'hello' , async ( ) => {
  return 'Hello world!' ;
} ) ;

ตอนนี้คุณสามารถเรียกใช้แบบสอบถามที่กำหนดเองได้โดยใช้ GraphQl Playground:

 query {
  hello
}

คุณควรได้รับคำตอบด้านล่าง:

{
  "data" : {
    "hello" : " Hello world! "
  }
}

เรียนรู้เพิ่มเติม

คู่มือ Parse GraphQL เป็นแหล่งที่ดีมากสำหรับการเรียนรู้วิธีใช้ Parse GraphQL API

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

นอกจากนี้ส่วน GraphQL Learn เป็นแหล่งที่ดีมากในการเรียนรู้เพิ่มเติมเกี่ยวกับพลังของภาษา GraphQL

การบริจาค

โปรดดูคู่มือการสนับสนุน

ผู้มีส่วนร่วม

โครงการนี้มีอยู่ขอบคุณทุกคนที่มีส่วนร่วม ... เราชอบที่จะเห็นใบหน้าของคุณในรายการนี้!

ผู้สนับสนุน

สนับสนุนโครงการนี้โดยการเป็นสปอนเซอร์ โลโก้ของคุณจะปรากฏขึ้นที่นี่พร้อมลิงค์ไปยังเว็บไซต์ของคุณ เป็นสปอนเซอร์!

ผู้สนับสนุน

สนับสนุนเราด้วยการบริจาครายเดือนและช่วยให้เราดำเนินกิจกรรมต่อไป เป็นผู้สนับสนุน!

[Server-options] http://parseplatform.org/parse-server/api/release/parseserveroptions.html

ขยาย