parse server
7.4.0
Parse Server ist ein Open -Source -Backend, das für jede Infrastruktur bereitgestellt werden kann, die node.js. Parse Server arbeitet mit dem Express -Webanwendungs -Framework. Es kann zu vorhandenen Webanwendungen hinzugefügt oder selbst ausgeführt werden.
Die vollständige Dokumentation für Parse Server ist im Wiki verfügbar. Der Parse Server -Handbuch ist ein guter Ort, um loszulegen. Eine API -Referenz- und Cloud -Code -Handbuch sind ebenfalls verfügbar. Wenn Sie sich für Parse Server entwickeln möchten, können Sie mit dem Entwicklungshandbuch eingerichtet werden.
Ein großes Dankeschön an unsere Sponsoren und Unterstützer, die die Entwicklung der Parse -Plattform unterstützen!
Parse Server ist in verschiedenen Geschmacksrichtungen in verschiedenen Zweigen verfügbar:
release-<version>.xx , z. B. release-5.xx , bezeichnet. LTS-Zweige haben keine Zweige. Long-Term Support (LTS) wird für die vorherige Parse Server-Major-Version bereitgestellt. Zum Beispiel erhält Parse Server 5.x Sicherheitsaktualisierungen, bis Parse Server 6.x von Parse Server 7.x ersetzt wird und zur neuen LTS -Version wird. Während die aktuelle Hauptversion in der Branch release veröffentlicht wird, wird eine LTS-Version in der Filiale release-#.xx , z. B. release-5.xx für den Parse Server 5.x LTS-Zweig veröffentlicht.
Der schnellste und einfachste Weg, um zu beginnen, besteht darin, MongoDB auszuführen und den Server lokal zu analysieren.
Bevor Sie beginnen, stellen Sie sicher, dass Sie installiert haben:
npm enthältParse Server wird kontinuierlich mit den neuesten Releases von Node.js getestet, um die Kompatibilität zu gewährleisten. Wir folgen dem Langzeitunterstützungsplan von Node.js und testen nur gegen Versionen, die offiziell unterstützt werden und ihr Datum am Ende des Lebens nicht erreicht haben.
| Version | Neueste Version | Lebensende | Kompatibel |
|---|---|---|---|
| Node.js 18 | 18.20.4 | April 2025 | ✅ Ja |
| Node.js 20 | 20.15.1 | April 2026 | ✅ Ja |
| Node.js 22 | 22.4.1 | April 2027 | ✅ Ja |
Parse Server wird kontinuierlich mit den neuesten Veröffentlichungen von MongoDB getestet, um die Kompatibilität zu gewährleisten. Wir folgen dem MongoDB-Support-Zeitplan und dem MongoDB-Lebenszyklusplan und werden nur gegen Versionen getestet, die offiziell unterstützt werden und ihr Datum am Ende des Lebens nicht erreicht haben. MongoDB "Rapid Releases" werden ignoriert, da diese als vorab der nächsten Hauptversion betrachtet werden.
| Version | Neueste Version | Lebensende | Kompatibel |
|---|---|---|---|
| MongoDB 4.2 | 4.2.25 | April 2023 | ✅ Ja |
| MongoDB 4.4 | 4.4.29 | Februar 2024 | ✅ Ja |
| MongoDB 5 | 5.0.26 | Oktober 2024 | ✅ Ja |
| MongoDB 6 | 6.0.14 | Juli 2025 | ✅ Ja |
| MongoDB 7 | 7.0.8 | Tdb | ✅ Ja |
| MongoDB 8 | 8.0.0 | Tdb | ✅ Ja |
Parse Server wird kontinuierlich mit den neuesten Veröffentlichungen von PostgreSQL und PostGIS getestet, um die Kompatibilität unter Verwendung von PostGIS -Docker -Bildern sicherzustellen. Wir folgen dem PostgreSQL-Support-Zeitplan und dem PostgIS-Unterstützungsplan und testen nur gegen Versionen, die offiziell unterstützt werden und ihr Datum am Ende des Lebens nicht erreicht haben. Aufgrund der umfangreichen PostgreSQL-Support-Dauer von 5 Jahren löscht Parse Server etwa 2 Jahre vor dem offiziellen Datum am offiziellen Lebensende.
| Version | Postgis -Version | Lebensende | Serverunterstützung analysieren | Kompatibel |
|---|---|---|---|---|
| Postgres 13 | 3,1, 3,2, 3,3, 3,4, 3,5 | November 2025 | <= 6.x (2023) | ✅ Ja |
| Postgres 14 | 3.5 | November 2026 | <= 7.x (2024) | ✅ Ja |
| Postgres 15 | 3.5 | November 2027 | <= 8.x (2025) | ✅ Ja |
| Postgres 16 | 3.5 | November 2028 | <= 9.x (2026) | ✅ Ja |
| Postgres 17 | 3.5 | November 2029 | <= 9.x (2026) | ✅ Ja |
$ npm install -g parse-server mongodb-runner
$ mongodb-runner start
$ parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://localhost/test Hinweis: Wenn die Installation mit -g aufgrund von Berechtigungsproblemen ( npm ERR! code 'EACCES' ) fehlschlägt, lesen Sie bitte diesen Link.
$ git clone https://github.com/parse-community/parse-server
$ cd parse-server
$ docker build --tag parse-server .
$ docker run --name my-mongo -d mongo$ 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 HINWEIS: Wenn Sie Cloud-Code verwenden möchten, fügen Sie -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js zum Befehl oben hinzu. Stellen Sie sicher, dass sich main.js im Verzeichnis von cloud-code-vol befindet, bevor Sie mit dem Parse Server beginnen.
Sie können jede beliebige Zeichenfolge als Anwendungs -ID und Master -Schlüssel verwenden. Diese werden von Ihren Clients verwendet, um sich mit dem Parse -Server zu authentifizieren.
Das war's! Sie führen jetzt eine eigenständige Version von Parse Server auf Ihrem Computer aus.
Verwenden Sie einen Remote -MongoDB? Übergeben Sie den Parameter --databaseURI DATABASE_URI wenn Sie parse-server starten. Weitere Informationen zum Konfigurieren von Parse Server finden Sie hier. Für eine vollständige Liste der verfügbaren Optionen führen Sie parse-server --help aus.
Nachdem Sie Parse Server ausführen, ist es Zeit, Ihr erstes Objekt zu speichern. Wir werden die Rest -API verwenden, aber Sie können mit einem der Parse SDKs problemlos dasselbe tun. Führen Sie Folgendes aus:
$ 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/GameScoreSie sollten eine ähnliche Antwort erhalten:
{
"objectId" : "2ntvSpRGIK" ,
"createdAt" : "2016-03-11T23:51:48.050Z"
} Sie können dieses Objekt jetzt direkt abrufen (stellen Sie sicher, dass Sie 2ntvSpRGIK durch das tatsächliche objectId ersetzen, das Sie beim Erstellen des Objekts erhalten haben):
$ 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 "
}Es ist jedoch nicht ideal, Tracks einzelner Objekt -IDs zu halten. In den meisten Fällen möchten Sie eine Abfrage über die Sammlung ausführen, wie Sie:
$ 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 "
}
]
}Weitere Informationen zum Einsatz von Speichern und Abfragen von Objekten auf Parse Server finden Sie in der Parse -Dokumentation.
Parse bietet SDKs für alle wichtigen Plattformen. Weitere Informationen finden Sie in der Anparse Server -Handbuch, um zu erfahren, wie Sie Ihre App mit dem Parse Server verbinden können.
Sobald Sie ein besseres Verständnis dafür haben, wie das Projekt funktioniert, finden Sie im Parse Server-Wiki für eingehende Anleitungen zum Bereitstellen von Parse Server für wichtige Infrastrukturanbieter. Lesen Sie weiter, um mehr über zusätzliche Möglichkeiten zum Ausführen von Parse Server zu erfahren.
Wir haben eine grundlegende Node.JS -Anwendung bereitgestellt, die das Parse Server -Modul auf Express verwendet und einfach für verschiedene Infrastrukturanbieter bereitgestellt werden kann:
Sie können auch eine Instanz von Parse Server erstellen und auf einer neuen oder vorhandenen Express -Website montieren:
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.' ) ;
} ) ; Für eine vollständige Liste der verfügbaren Optionen führen Sie parse-server --help aus oder schauen Sie sich [Parse Server-Konfigurationen] [Server-Options] an.
Überprüfen Sie den Parse Server Health, indem Sie eine Anfrage an den Endpunkt /parse/health -Endpunkt senden.
Die Antwort sieht so aus:
{
"status" : " ok "
}| Wert | Beschreibung |
|---|---|
initialized | Der Server wurde erstellt, aber die start wurde noch nicht aufgerufen. |
starting | Der Server startet. |
ok | Der Server begann und läuft. |
error | Es gab einen Startfehler. Weitere Informationen finden Sie in den Protokollen. |
Parse Server kann mit den folgenden Optionen konfiguriert werden. Sie können diese als Parameter übergeben, wenn Sie ein eigenständiges parse-server ausführen oder eine Konfigurationsdatei im JSON-Format mithilfe von parse-server path/to/configuration.json laden. Wenn Sie Parse Server on Express verwenden, können Sie diese auch als Optionen an das ParseServer -Objekt weitergeben.
Für die vollständige Liste der verfügbaren Optionen führen Sie parse-server --help aus oder schauen Sie sich [Parse Server-Konfigurationen] [Server-Options] an.
appId (erforderlich) - Die Anwendungs -ID zum Host mit dieser Serverinstanz. Sie können jede beliebige Zeichenfolge verwenden. Für migrierte Apps sollte dies mit Ihrer gehosteten Parse -App übereinstimmen.masterKey (Erforderlich) - Der Hauptschlüssel, der für die überschreibende ACL -Sicherheit verwendet werden soll. Sie können jede beliebige Zeichenfolge verwenden. Halte es geheim! Für migrierte Apps sollte dies mit Ihrer gehosteten Parse -App übereinstimmen.databaseURI (erforderlich) - Die Verbindungszeichenfolge für Ihre Datenbank, dh mongodb://user:[email protected]/dbname . Stellen Sie sicher, dass URL Ihr Kennwort codieren, wenn Ihr Passwort Sonderzeichen enthält.port - Der Standardport ist 1337, geben Sie diesen Parameter an, um einen anderen Port zu verwenden.serverURL - URL zu Ihrem Parse -Server (Vergessen Sie nicht, http: // oder https: // anzugeben). Diese URL wird verwendet, wenn Anfragen zum Parsen von Server aus dem Cloud -Code analysiert werden.cloud - Der absolute Pfad zu Ihrer Cloud -Code main.js -Datei.push - Konfigurationsoptionen für APNs und GCM Push. Sehen Sie den schnellen Start der Push -Benachrichtigungen. Die mit Parse verwendeten Clientschlüssel sind mit Parse Server nicht mehr erforderlich. Wenn Sie sie noch benötigen möchten, können Sie die Schlüssel zum Initialisierungszeit einstellen, um den Zugriff auf ältere Kunden abzulehnen. Durch das Festlegen eines dieser Schlüssel sind alle Anfragen erforderlich, um einen der konfigurierten Schlüssel bereitzustellen.
clientKeyjavascriptKeyrestAPIKeydotNetKey| Umfang | Interne Daten | Schreibgeschützte Daten (1) | Benutzerdefinierte Daten | Eingeschränkt durch CLP, ACL | Schlüssel |
|---|---|---|---|---|---|
| Intern | r/w | r/w | r/w | NEIN | maintenanceKey |
| Master | -/- | R/- | r/w | NEIN | masterKey |
| Readonlymaster | -/- | R/- | R/- | NEIN | readOnlyMasterKey |
| Sitzung | -/- | R/- | r/w | Ja | sessionToken |
(1) Parse.Object.createdAt , Parse.Object.updatedAt .
Überprüfen Sie die E -Mail -Adressen der Benutzer und Aktivieren des Zurücksetzens des Kennworts per E -Mail müssen ein E -Mail -Adapter. Es gibt viele E -Mail -Adapter, die von der Community bereitgestellt und verwaltet werden. Das Folgende ist eine Beispielkonfiguration mit einem Beispiel -E -Mail -Adapter. Weitere Informationen und eine vollständige Liste der verfügbaren Optionen finden Sie in den Optionen [Server-Server] [Server-Optionen].
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
}
} ,
} ) ;Offizielle E -Mail -Adapter, die von Parse Platform gepflegt wurden:
E -Mail -Adapter, die von der Community beigetragen haben:
Legen Sie eine Passwort- und Kontorichtlinie fest, die Ihren Sicherheitsanforderungen entspricht. Das Folgende ist eine Beispielkonfiguration. Weitere Informationen und eine vollständige Liste der verfügbaren Optionen finden Sie in den Optionen [Server-Server] [Server-Optionen].
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 ,
} ,
} ) ; Vorsicht, dies ist ein experimentelles Merkmal, das möglicherweise nicht für die Produktion geeignet ist.
Benutzerdefinierte Routen ermöglichen das Erstellen von Benutzerströmen mit Webseiten, ähnlich wie bei den vorhandenen Funktionen für das Zurücksetzen und die E -Mail -Überprüfung der E -Mail. Benutzerdefinierte Routen werden mit der Option pages in der Konfiguration von Parse Server definiert:
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' } ;
}
} ]
}
} Die obige Route kann aufgerufen werden, indem eine GET -Anfrage an: https://[parseServerPublicUrl]/[parseMount]/[pagesEndpoint]/[appId]/[customRoute] gesendet werden:
Der handler empfängt die request und gibt eine Webseite von custom_page.html von den Seiten pages.pagesPath als Antwort zurück. Der Vorteil des Erstellens einer benutzerdefinierten Route auf diese Weise besteht darin, dass die integrierten Funktionen von Parse Server automatisch verwendet werden, z. B. die Lokalisierung von Seiten und dynamische Platzhalter.
Die folgenden Pfade werden bereits von den integrierten Funktionen des Parse Servers verwendet und sind daher für benutzerdefinierte Routen nicht verfügbar. Benutzerdefinierte Routen mit einer identischen Kombination aus path und method werden ignoriert.
| Weg | HTTP -Methode | Besonderheit |
|---|---|---|
verify_email | GET | E -Mail -Überprüfung |
resend_verification_email | POST | E -Mail -Überprüfung |
choose_password | GET | Passwort zurücksetzen |
request_password_reset | GET | Passwort zurücksetzen |
request_password_reset | POST | Passwort zurücksetzen |
| Parameter | Optional | Typ | Standardwert | Beispielwerte | Umgebungsvariable | Beschreibung |
|---|---|---|---|---|---|---|
pages | Ja | Object | undefined | - - | PARSE_SERVER_PAGES | Die Optionen für Seiten wie das Zurücksetzen des Kennworts und die Überprüfung der E -Mail. |
pages.enableRouter | Ja | Boolean | false | - - | PARSE_SERVER_PAGES_ENABLE_ROUTER | Ist true , wenn der Seitenrouter aktiviert sein sollte; Dies ist erforderlich, damit die Seitenoptionen wirksam werden. Vorsicht, dies ist ein experimentelles Merkmal, das möglicherweise nicht für die Produktion geeignet ist. |
pages.customRoutes | Ja | Array | [] | - - | PARSE_SERVER_PAGES_CUSTOM_ROUTES | Die benutzerdefinierten Routen. Die Routen werden in der Reihenfolge hinzugefügt, die sie hier definiert sind, was berücksichtigt werden muss, da die Anfragen von Traverse -Routen in geordneter Weise geeignet sind. Benutzerdefinierte Routen werden nach Aufbau von Routen wie dem Zurücksetzen des Kennworts und der E-Mail-Überprüfung durchquert. |
pages.customRoutes.method | String | - - | GET , POST | - - | Die HTTP -Methode der benutzerdefinierten Route. | |
pages.customRoutes.path | String | - - | custom_page | - - | Der Weg der benutzerdefinierten Route. Beachten Sie, dass der gleiche Pfad verwendet werden kann, wenn die method unterschiedlich ist. Beispielsweise kann ein Pfad custom_page zwei Routen haben, eine GET und POST -Route, die je nach HTTP -Anforderungsmethode aufgerufen wird. | |
pages.customRoutes.handler | AsyncFunction | - - | async () => { ... } | - - | Der Routenhandler, der aufgerufen wird, wenn die Route mit der HTTP -Anfrage übereinstimmt. Wenn der Handler keine Seite zurückgibt, wird die Anfrage mit einem Not found. Antwort. |
Es ist möglich, die Standardseiten der App zu ändern und den Benutzer auf einen anderen Pfad oder eine andere Domäne umzuleiten.
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"
}
} ) Sie können den Parse -Server mithilfe von Umgebungsvariablen konfigurieren:
PORT
PARSE_SERVER_APPLICATION_ID
PARSE_SERVER_MASTER_KEY
PARSE_SERVER_DATABASE_URI
PARSE_SERVER_URL
PARSE_SERVER_CLOUDDer Standardport ist 1337, um einen anderen Port zu verwenden, um die Portvariable der Portumgebungsumgebung festzulegen:
$ PORT=8080 parse-server --appId APPLICATION_ID --masterKey MASTER_KEY Führen Sie parse-server --help aus oder schauen Sie sich die Parse-Server-Konfiguration an.
Alle offiziellen Adapter werden als Scoped -Pakete auf NPM (@Parse) verteilt.
Einige gut gepflegte Adapter sind auch in der Organisation Parse Server Module verfügbar.
Sie können auch mehr Adapter finden, die von der Community auf der Suche nach NPM gepflegt werden.
Mit Parse Server können Entwickler beim Hosting von Dateien aus mehreren Optionen auswählen:
GridFSBucketAdapter - der von MongoDB unterstützt wirdS3Adapter - der von Amazon S3 unterstützt wirdGCSAdapter - das von Google Cloud Storage unterstützt wirdFSAdapter - Lokale Dateispeicher GridFSBucketAdapter wird standardmäßig verwendet und erfordert kein Einrichten. Wenn Sie jedoch an der Verwendung von Amazon S3, Google Cloud -Speicher oder lokalem Dateispeicher interessiert sind, finden Sie zusätzliche Konfigurationsinformationen im Parse Server -Handbuch.
Vorsicht, dies ist ein experimentelles Merkmal, das möglicherweise nicht für die Produktion geeignet ist.
Diese Funktion widmet identische Anforderungen, die mehrmals vom Parse Server empfangen werden, normalerweise aufgrund von Netzwerkproblemen oder Einschränkungen für Netzwerkadapterzugriffsbeschränkungen für mobile Betriebssysteme.
Identische Anfragen werden durch ihren Anfrage-Header X-Parse-Request-Id identifiziert. Daher muss eine Client -Anfrage diesen Header aufnehmen, damit die Deduplizierung angewendet wird. Anfragen, die diesen Header nicht enthalten, können nicht dedupliziert werden und werden normalerweise von Parse Server verarbeitet. Dies bedeutet, dass die Einführung dieser Funktion an Clients nahtlos ist, da Parse Server Anforderungen ohne diesen Header weiter verarbeitet, wenn diese Funktion aktiviert ist.
Diese Funktion muss auf der Client -Seite aktiviert werden, um den Header und auf dem Server zu senden, um den Header zu verarbeiten. Siehe die spezifischen SDK -Dokumente, um festzustellen, ob die Funktion noch unterstützt wird.
Die Deduplizierung erfolgt nur für die Erstellung und das Update von Objekten ( POST und PUT ). Die Deduplizierung erfolgt nicht für Objekt -Erkenntnisse und -Löhen (Anfragen GET und DELETE ), da diese Vorgänge bereits per Definition idempotent sind.
let api = new ParseServer({
idempotencyOptions: {
paths: [".*"], // enforce for all requests
ttl: 120 // keep request IDs for 120s
}
}
| Parameter | Optional | Typ | Standardwert | Beispielwerte | Umgebungsvariable | Beschreibung |
|---|---|---|---|---|---|---|
idempotencyOptions | Ja | Object | undefined | Parse_server_experimental_idempotency_options | Durch die Einstellung dieser IDEmpoTency -Durchsetzung für die angegebenen Pfade. | |
idempotencyOptions.paths | Ja | Array<String> | [] | .* (Alle Pfade enthält die folgenden Beispiele),functions/.* (alle Funktionen),jobs/.* (alle Jobs),classes/.* (alle Klassen),functions/.* (alle Funktionen),users (Benutzererstellung / Update),installations (Installationserstellung / Update) | Parse_server_experimental_idempotency_paths | Ein Array von Pfadmutern, die mit dem Anforderungspfad übereinstimmen müssen, um die Anforderung zu aktivieren. Der Mount -Pfad darf nicht enthalten sein, zum Beispiel, um den Anforderungsweg /parse/functions/myFunction anzupassen, geben Sie die functions/myFunction an. Ein nachverfolgender Schrägstrich des Anforderungspfads wird ignoriert, beispielsweise entspricht die functions/myFunction sowohl /parse/functions/myFunction und /parse/functions/myFunction/ . |
idempotencyOptions.ttl | Ja | Integer | 300 | 60 (60 Sekunden) | Parse_server_experimental_idempotency_ttl | Die Dauer in Sekunden danach wird ein Anforderungsdatensatz aus der Datenbank verworfen. Es ist zu erwarten, dass doppelte Anfragen aufgrund von Netzwerkproblemen bis zu mehreren Sekunden innerhalb von Millisekunden eintreffen. Dieser Wert muss größer als 0 sein. |
Um diese Funktion in Postgres zu verwenden, müssen Sie einen Cron -Job mit PGADMIN oder ähnlich erstellen, um die Postgres -Funktion idempotency_delete_expired_records() aufzurufen, die abgelaufene IDempoTency -Datensätze löscht. Sie finden unten ein Beispielskript. Stellen Sie sicher, dass das Skript über die gleichen Berechtigungen verfügt, um sich bei Postgres als Parse Server anzumelden.
#! /bin/bash
set -e
psql -v ON_ERROR_STOP=1 --username " $POSTGRES_USER " --dbname " $POSTGRES_DB " << - EOSQL
SELECT idempotency_delete_expired_records();
EOSQL
exec " $@ " Unter der Annahme, dass das obige Skript benannt ist, ist parse_idempotency_delete_expired_records.sh , ein Cron -Job, in dem das Skript alle 2 Minuten ausgeführt wird, wie:
2 * * * * /root/parse_idempotency_delete_expired_records.sh > /dev/null 2>&1 Vorsicht, dies ist ein experimentelles Merkmal, das möglicherweise nicht für die Produktion geeignet ist.
Benutzerdefinierte Seiten sowie Feature -Seiten (z. B. Zurücksetzen des Kennworts, E -Mail -Überprüfung) können mit der pages in der Parse Server -Konfiguration lokalisiert werden:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
}
} Die Lokalisierung wird erreicht, indem ein locale mit lokalisiertem Seiteninhalt übereinstimmt. Das Gebietsschema kann entweder in der Anforderungsanfrage, in der Karosserie oder in den Header mit den folgenden Schlüssel geliefert werden:
localelocalex-parse-page-param-localeBeispielsweise könnte ein Link zum Zurücksetzen des Kennworts mit dem Parameter des Gebietsschemas in der Abfrage so aussehen:
http://example.com/parse/apps/[appId]/request_password_reset?token=[token]&username=[username]&locale=de-AT
pages.pagesPath .pages.customUrls festgelegt werden..html -Dateien werden für die Lokalisierung berücksichtigt, wenn Sie benutzerdefinierte Seiten lokalisieren.Seiten können auf zwei Arten lokalisiert werden:
Seiten werden unter Verwendung der entsprechenden Datei in der Verzeichnisstruktur lokalisiert, in der die Dateien in Unterverzeichnissen platziert werden, die nach dem Gebietsschema oder der Sprache benannt sind. Die Datei im Basisverzeichnis ist die Standarddatei.
Beispielverzeichnisstruktur:
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 fileDateien werden in der folgenden Reihenfolge mit dem Gebietsschema übereinstimmen:
de-AT -Übereinstimmung Datei in Ordner de-AT .de-CH Datei in Ordner de .Konfigurationsbeispiel:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
customUrls : {
passwordReset : 'https://example.com/page.html'
}
}
}Profis:
Nachteile:
Seiten werden lokalisiert, indem Platzhalter in die HTML -Dateien hinzugefügt und eine JSON -Ressource bereitgestellt werden, die die Übersetzungen enthält, die sich in die Platzhalter füllen können.
Beispielverzeichnisstruktur:
root /
├── public / // pages base path
│ ├── example . html // the page containing placeholders
├── private / // folder outside of public scope
│ └── translations . json // JSON resource fileDie JSON -Ressourcendatei folgt locker der I18Next -Syntax, die eine Syntax ist, die häufig von Übersetzungsplattformen unterstützt wird, so dass es einfach ist, Übersetzungen zu verwalten, sie für die Verwendung im Parse -Server zu exportieren und diesen Workflow sogar zu automatisieren.
Beispiel JSON Inhalt:
{
"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! "
}
}
}Konfigurationsbeispiel:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
localizationJsonPath : './private/localization.json' ,
localizationFallbackLocale : 'en'
}
}Profis:
Nachteile:
Zusätzlich zu den featurenbezogenen Standardparametern wie appId und den über JSON -Ressource bereitgestellten Übersetzungen ist es möglich, benutzerdefinierte dynamische Platzhalter als Teil der Routerkonfiguration zu definieren. Dies funktioniert unabhängig von der Lokalisierung und auch, wenn enableLocalization deaktiviert ist.
Konfigurationsbeispiel:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
placeholders : {
exampleKey : 'exampleValue'
}
}
} Die Platzhalter können auch als Funktion oder als asynchronisierte Funktion bereitgestellt werden, wobei das locale und andere mit Features verwandte Parameter übergeben werden, um dynamische Platzhalterwerte zu ermöglichen:
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
} ;
}
}
} Die folgenden Parameter- und Platzhalterschlüssel sind reserviert, da sie in Bezug auf Funktionen wie das Zurücksetzen des Kennworts oder die E -Mail -Überprüfung verwendet werden. Sie sollten nicht als Übersetzungsschlüssel in der JSON -Ressource oder als manuell definierte Platzhalterschlüssel in der Konfiguration verwendet werden: appId , appName , email , error , locale , publicServerUrl , token , username .
| Parameter | Optional | Typ | Standardwert | Beispielwerte | Umgebungsvariable | Beschreibung |
|---|---|---|---|---|---|---|
pages | Ja | Object | undefined | - - | PARSE_SERVER_PAGES | Die Optionen für Seiten wie das Zurücksetzen des Kennworts und die Überprüfung der E -Mail. |
pages.enableRouter | Ja | Boolean | false | - - | PARSE_SERVER_PAGES_ENABLE_ROUTER | Ist true , wenn der Seitenrouter aktiviert sein sollte; Dies ist erforderlich, damit die Seitenoptionen wirksam werden. Vorsicht, dies ist ein experimentelles Merkmal, das möglicherweise nicht für die Produktion geeignet ist. |
pages.enableLocalization | Ja | Boolean | false | - - | PARSE_SERVER_PAGES_ENABLE_LOCALIZATION | Ist wahr, wenn Seiten lokalisiert werden sollten; Dies hat keinen Einfluss auf benutzerdefinierte Seitenumleitungen. |
pages.localizationJsonPath | Ja | String | undefined | ./private/translations.json | PARSE_SERVER_PAGES_LOCALIZATION_JSON_PATH | Der Pfad zur JSON -Datei zur Lokalisierung; Die Übersetzungen werden verwendet, um Vorlagen -Platzhalter gemäß dem Gebietsschema zu füllen. |
pages.localizationFallbackLocale | Ja | String | en | en , en-GB , default | PARSE_SERVER_PAGES_LOCALIZATION_FALLBACK_LOCALE | Das Fallback -Gebiet für die Lokalisierung, wenn für das angegebene Gebietsschema keine übereinstimmende Übersetzung vorgesehen ist. Dies ist nur relevant, wenn Übersetzungsressourcen über JSON -Datei bereitgestellt werden. |
pages.placeholders | Ja | Object , Function , AsyncFunction | undefined | { exampleKey: 'exampleValue' } | PARSE_SERVER_PAGES_PLACEHOLDERS | Die Platzhalterschlüssel und Werte, die auf Seiten ausgefüllt werden; Dies kann ein einfaches Objekt oder eine Rückruffunktion sein. |
pages.forceRedirect | Ja | Boolean | false | - - | PARSE_SERVER_PAGES_FORCE_REDIRECT | Ist true , wenn Antworten immer umgeleitet werden und niemals Inhalte, false wenn der Antworttyp vom Anforderungsart abhängen sollte ( GET -> Inhaltsantwort; POST -> Antwort umleiten). |
pages.pagesPath | Ja | String | ./public | ./files/pages , ../../pages | PARSE_SERVER_PAGES_PAGES_PATH | Der Weg zum Seitenverzeichnis; Dies definiert auch, wohin der statische Endpunkt /apps zeigt. |
pages.pagesEndpoint | Ja | String | apps | - - | PARSE_SERVER_PAGES_PAGES_ENDPOINT | Der API -Endpunkt für die Seiten. |
pages.customUrls | Ja | Object | {} | { passwordReset: 'https://example.com/page.html' } | PARSE_SERVER_PAGES_CUSTOM_URLS | Die URLs zu den benutzerdefinierten Seiten |
pages.customUrls.passwordReset | Ja | String | password_reset.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET | Die URL zur benutzerdefinierten Seite zum Zurücksetzen des Passworts. |
pages.customUrls.passwordResetSuccess | Ja | String | password_reset_success.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_SUCCESS | Die URL zur benutzerdefinierten Seite zum Zurücksetzen des Kennworts -> Erfolg. |
pages.customUrls.passwordResetLinkInvalid | Ja | String | password_reset_link_invalid.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_LINK_INVALID | Die URL zur benutzerdefinierten Seite für das Kennwort zurückgesetzt -> Link ungültig. |
pages.customUrls.emailVerificationSuccess | Ja | String | email_verification_success.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SUCCESS | Die URL zur benutzerdefinierten Seite zur E -Mail -Überprüfung -> Erfolg. |
pages.customUrls.emailVerificationSendFail | Ja | String | email_verification_send_fail.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_FAIL | Die URL zur benutzerdefinierten Seite für E -Mail -Überprüfung -> Link senden fehl. |
pages.customUrls.emailVerificationSendSuccess | Ja | String | email_verification_send_success.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_SUCCESS | Die URL zur benutzerdefinierten Seite für die E -Mail -Überprüfung -> Link wiedergeben -> Erfolg. |
pages.customUrls.emailVerificationLinkInvalid | Ja | String | email_verification_link_invalid.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_INVALID | Die URL zur benutzerdefinierten Seite für E -Mail -Überprüfung -> Link ungültig. |
pages.customUrls.emailVerificationLinkExpired | Ja | String | email_verification_link_expired.html | - - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_EXPIRED | Die URL zur benutzerdefinierten Seite für E -Mail -Überprüfung -> Link ist abgelaufen. |
Parse Server wird standardmäßig protokollieren:
Protokolle sind auch in Parse Dashboard zu sehen.
Möchten Sie jede Anfrage und Antwort protokollieren? Legen Sie die VERBOSE Umgebungsvariable fest, wenn Sie mit parse-server beginnen. Verwendung: VERBOSE='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Möchten Sie, dass Protokolle in einen anderen Ordner platziert werden? Übergeben Sie die Umgebungsvariable PARSE_SERVER_LOGS_FOLDER , wenn Sie mit parse-server beginnen. Verwendung: PARSE_SERVER_LOGS_FOLDER='<path-to-logs-folder>' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Möchten Sie bestimmte Ebenen protokollieren? Geben Sie den Parameter logLevel beim Starten parse-server über. Verwendung:-PARSE parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --logLevel LOG_LEVEL
Möchten Sie eine neue Zeile abgrenzte JSON -Fehlerprotokolle (für den Verbrauch durch CloudWatch, Google Cloud -Protokollierung usw.)? Übergeben Sie die Variable JSON_LOGS Umgebung, wenn Sie mit parse-server beginnen. Verwendung: JSON_LOGS='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Sehen Sie sich den Abschaltplan für einen Überblick über die Abschreibungen und die geplanten Veränderungen an.
Live-Abfragen sollen in reaktiven Echtzeitanwendungen verwendet werden, bei denen nur das herkömmliche Abfrageparadigma zu mehreren Problemen führen kann, z. Live-Abfragen sollten in Fällen verwendet werden, in denen Sie eine Seite mit neuen Daten aus der Datenbank kontinuierlich aktualisieren müssen, die häufig in Online-Spielen, Messaging-Clients und gemeinsam genutzten To-Do-Listen auftreten (aber nicht beschränkt ist).
Schauen Sie sich Live Query Guide, Live Query Server -Setup -Handbuch und Live -Abfrageprotokollspezifikation an. Sie können einen eigenständigen Server oder mehrere Instanzen zur Skalierbarkeit einrichten (empfohlen).
GraphQL, entwickelt von Facebook, ist eine Open-Source-Datenabfrage und eine Manipulationssprache für APIs. Neben der herkömmlichen REST -API generiert Parse Server automatisch eine GraphQL -API basierend auf Ihrem aktuellen Anwendungsschema. Mit Parse Server können Sie auch Ihre benutzerdefinierten GraphQL -Abfragen und -mutationen definieren, deren Resolver an Ihre Cloud -Code -Funktionen gebunden werden können.
Der einfachste Weg, die Parse -GraphQL -API durch die CLI auszuführen:
$ 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 --mountPlaygroundNach dem Start des Servers können Sie http: // localhost: 1337/Playground in Ihrem Browser besuchen, um mit Ihrer GraphQL -API zu spielen.
Hinweis: Verwenden Sie keine -Mountplayground -Option in der Produktion. Parse Dashboard verfügt über einen integrierten GraphQL-Spielplatz und ist die empfohlene Option für Produktions-Apps.
Sie können auch die Parse GraphQL -API in einem Docker -Container ausführen:
$ git clone https://github.com/parse-community/parse-server
$ cd parse-server
$ docker build --tag parse-server .
$ docker run --name my-mongo -d mongo$ 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 HINWEIS: Wenn Sie Cloud-Code verwenden möchten, fügen Sie -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js zum Befehl oben hinzu. Stellen Sie sicher, dass sich main.js im Verzeichnis von cloud-code-vol befindet, bevor Sie mit dem Parse Server beginnen.
Nach dem Start des Servers können Sie http: // localhost: 1337/Playground in Ihrem Browser besuchen, um mit Ihrer GraphQL -API zu spielen.
Hinweis: Verwenden Sie keine -Mountplayground -Option in der Produktion. Parse Dashboard verfügt über einen integrierten GraphQL-Spielplatz und ist die empfohlene Option für Produktions-Apps.
Sie können die GraphQL -API auch in einer Express.js -Anwendung zusammen mit der Rest -API oder Solo montieren. Sie müssen zunächst ein neues Projekt erstellen und die erforderlichen Abhängigkeiten installieren:
$ mkdir my-app
$ cd my-app
$ npm install parse-server express --save Erstellen Sie dann eine index.js -Datei mit dem folgenden Inhalt:
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' ) ;
} ) ;Und starten Sie schließlich Ihre App:
$ npx mongodb-runner start
$ node index.jsNach dem Start der App können Sie http: // localhost: 1337/Playground in Ihrem Browser besuchen, um mit Ihrer GraphQL -API zu spielen.
HINWEIS: Machen Sie den GraphQL -Spielplatz nicht in der Produktion. Parse Dashboard verfügt über einen integrierten GraphQL-Spielplatz und ist die empfohlene Option für Produktions-Apps.
Führen Sie Folgendes aus:
query Health {
health
}Sie sollten die folgende Antwort erhalten:
{
"data" : {
"health" : true
}
} Da Ihre Anwendung noch kein Schema hat, können Sie die Mutation für die createClass -Mutation verwenden, um Ihre erste Klasse zu erstellen. Führen Sie Folgendes aus:
mutation CreateClass {
createClass (
name : " GameScore "
schemaFields : {
addStrings : [{ name : " playerName " }]
addNumbers : [{ name : " score " }]
addBooleans : [{ name : " cheatMode " }]
}
) {
name
schemaFields {
name
__typename
}
}
}Sie sollten die folgende Antwort erhalten:
{
"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 lernte aus der ersten Klasse, die Sie erstellt haben, und jetzt haben Sie die GameScore -Klasse in Ihrem Schema. Sie können jetzt mit den automatisch generierten Vorgängen beginnen!
Führen Sie Folgendes aus, um Ihr erstes Objekt zu erstellen:
mutation CreateGameScore {
createGameScore (
fields : {
playerName : " Sean Plott "
score : 1337
cheatMode : false
}
) {
id
updatedAt
createdAt
playerName
score
cheatMode
ACL
}
}Sie sollten eine ähnliche Antwort erhalten:
{
"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
}
}
}Sie können auch eine Abfrage in diese neue Klasse ausführen:
query GameScores {
gameScores {
results {
id
updatedAt
createdAt
playerName
score
cheatMode
ACL
}
}
}Sie sollten eine ähnliche Antwort erhalten:
{
"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
}
]
}
}
}Mit dem Parse GraphQL Server können Sie ein benutzerdefiniertes GraphQL-Schema mit eigenen Abfragen und Mutationen erstellen, die mit den automatischen generierten zusammengeführt werden sollen. Sie können diese Vorgänge mit Ihren regulären Cloud -Code -Funktionen beheben.
Um Ihr benutzerdefiniertes Schema zu erstellen, müssen Sie eine schema.graphql -Datei codieren und Parse Server mit --graphQLSchema und --cloud -Optionen initialisieren:
$ 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 Verwenden Sie den folgenden Code für Ihr schema.graphql und main.js -Dateien. Starten Sie dann Ihren Parse -Server neu.
# schema.graphql
extend type Query {
hello : String ! @resolve
} // main.js
Parse . Cloud . define ( 'hello' , async ( ) => {
return 'Hello world!' ;
} ) ;Sie können jetzt Ihre benutzerdefinierte Abfrage über den GraphQL -Spielplatz ausführen:
query {
hello
}Sie sollten die folgende Antwort erhalten:
{
"data" : {
"hello" : " Hello world! "
}
}Die Parse GraphQL -Handbuch ist eine sehr gute Quelle, um zu lernen, wie man die Parse GraphQL -API verwendet.
Sie haben auch ein sehr leistungsfähiges Tool in Ihrem GraphQL -Spielplatz. Bitte schauen Sie sich die rechte Seite Ihres GraphQL -Spielplatzes an. Sie werden die DOCS und SCHEMA -Menüs sehen. Sie werden automatisch durch Analyse Ihres Anwendungsschemas generiert. Bitte beziehen Sie sich auf sie und erfahren Sie mehr über alles, was Sie mit Ihrer Parse GraphQL -API tun können.
Darüber hinaus ist der Abschnitt GraphQL Learn eine sehr gute Quelle, um mehr über die Kraft der GraphQL -Sprache zu erfahren.
Bitte beachten Sie den leitenden Anleitung.
Dieses Projekt besteht dank all der Menschen, die dazu beitragen ... Wir würden gerne Ihr Gesicht auf dieser Liste sehen!
Unterstützen Sie dieses Projekt, indem Sie Sponsor werden. Ihr Logo wird hier mit einem Link zu Ihrer Website angezeigt. Werden Sie Sponsor!
Unterstützen Sie uns mit einer monatlichen Spende und helfen Sie uns, unsere Aktivitäten fortzusetzen. Werden Sie ein Unterstützer!
[Server-options] http://parseplatform.org/parse-server/api/release/parseserveroptions.html
