parse server
7.4.0
Parse Server est un backend open source qui peut être déployé dans n'importe quelle infrastructure qui peut exécuter Node.js. Parse Server fonctionne avec le framework d'application Web express. Il peut être ajouté aux applications Web existantes ou exécutées par elle-même.
La documentation complète de Parse Server est disponible dans le wiki. Le Guide du serveur Parse est un bon endroit pour commencer. Un guide de référence API et de code cloud est également disponible. Si vous êtes intéressé à développer pour Parse Server, le guide de développement vous aidera à vous installer.
Un grand merci à nos sponsors et bailleurs de fonds qui soutiennent le développement de la plate-forme d'analyse!
Parse Server est disponible en différentes saveurs sur différentes branches:
release-<version>.xx , par exemple release-5.xx . Les succursales LTS n'ont pas de succursales pré-version. Le soutien à long terme (LTS) est fourni pour la version majeure précédente du serveur Parse. Par exemple, Parse Server 5.x recevra des mises à jour de sécurité jusqu'à ce que Parse Server 6.x soit remplacé par Parse Server 7.x et devient la nouvelle version LTS. Bien que la version majeure actuelle soit publiée sur release de la branche, une version LTS est publiée sur release-#.xx , par exemple release-5.xx pour la branche LTS 5.x Parse Server.
Le moyen le plus rapide et le plus simple de commencer est d'exécuter le serveur MongoDB et d'analyse localement.
Avant de commencer à vous assurer que vous avez installé:
npmParse Server est testé en continu avec les versions les plus récentes de Node.js pour assurer la compatibilité. Nous suivons le plan de support à long terme Node.js et ne testons que des versions qui sont officiellement soutenues et n'ont pas atteint leur date de fin de vie.
| Version | Dernière version | Fin de vie | Compatible |
|---|---|---|---|
| Node.js 18 | 18.20.4 | Avril 2025 | ✅ Oui |
| Node.js 20 | 20.15.1 | Avril 2026 | ✅ Oui |
| Node.js 22 | 22.4.1 | Avril 2027 | ✅ Oui |
Parse Server est testé en continu avec les versions les plus récentes de MongoDB pour assurer la compatibilité. Nous suivons le calendrier de support MongoDB et le calendrier du cycle de vie MongoDB et ne testons que les versions qui sont officiellement soutenues et n'ont pas atteint leur date de fin de vie. Les "versions rapides" de MongoDB sont ignorées car celles-ci sont considérées comme des pré-sorties de la prochaine version majeure.
| Version | Dernière version | Fin de vie | Compatible |
|---|---|---|---|
| MongoDB 4.2 | 4.2.25 | Avril 2023 | ✅ Oui |
| MongoDB 4.4 | 4.4.29 | Février 2024 | ✅ Oui |
| MongoDB 5 | 5.0.26 | Octobre 2024 | ✅ Oui |
| MongoDB 6 | 6.0.14 | Juillet 2025 | ✅ Oui |
| MongoDB 7 | 7.0.8 | TDB | ✅ Oui |
| MongoDB 8 | 8.0.0 | TDB | ✅ Oui |
Parse Server est testé en continu avec les versions les plus récentes de PostgreSQL et PostGIS pour assurer la compatibilité, en utilisant les images PostGIS Docker. Nous suivons le calendrier de support PostgreSQL et le calendrier de support PostGIS et ne testons que des versions qui sont officiellement soutenues et n'ont pas atteint leur date de fin de vie. En raison de la longue durée du support PostgreSQL de 5 ans, Parse Server supprime le support environ 2 ans avant la date officielle de fin de vie.
| Version | Version postgis | Fin de vie | Prise en charge du serveur d'analyse | Compatible |
|---|---|---|---|---|
| Postgres 13 | 3.1, 3.2, 3,3, 3,4, 3,5 | Novembre 2025 | <= 6.x (2023) | ✅ Oui |
| Postgres 14 | 3.5 | Novembre 2026 | <= 7.x (2024) | ✅ Oui |
| Postgres 15 | 3.5 | Novembre 2027 | <= 8.x (2025) | ✅ Oui |
| Postgres 16 | 3.5 | Novembre 2028 | <= 9.x (2026) | ✅ Oui |
| Postgres 17 | 3.5 | Novembre 2029 | <= 9.x (2026) | ✅ Oui |
$ npm install -g parse-server mongodb-runner
$ mongodb-runner start
$ parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --databaseURI mongodb://localhost/test Remarque: Si l'installation avec -g échoue en raison de problèmes d'autorisation ( npm ERR! code 'EACCES' ), veuillez vous référer à ce lien.
$ 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 Remarque: Si vous souhaitez utiliser le code cloud, ajoutez -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js à la commande ci-dessus. Assurez-vous que main.js est dans le répertoire cloud-code-vol avant de démarrer le serveur d'analyse.
Vous pouvez utiliser n'importe quelle chaîne arbitraire comme ID d'application et clé maître. Ceux-ci seront utilisés par vos clients pour s'authentifier avec le serveur Parse.
C'est ça! Vous exécutez maintenant une version autonome de Parse Server sur votre machine.
En utilisant un mongodb éloigné? Passez le paramètre --databaseURI DATABASE_URI lors du démarrage parse-server . En savoir plus sur la configuration de Parse Server ici. Pour une liste complète des options disponibles, exécutez parse-server --help .
Maintenant que vous exécutez Parse Server, il est temps d'enregistrer votre premier objet. Nous utiliserons l'API REST, mais vous pouvez facilement faire de même en utilisant l'un des SDK d'analyse. Exécutez ce qui suit:
$ 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/GameScoreVous devriez obtenir une réponse similaire à ceci:
{
"objectId" : "2ntvSpRGIK" ,
"createdAt" : "2016-03-11T23:51:48.050Z"
} Vous pouvez désormais récupérer cet objet directement (assurez-vous de remplacer 2ntvSpRGIK par l' objectId réel que vous avez reçu lorsque l'objet a été créé):
$ 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 "
}Il n'est cependant pas idéal de garder des pistes des ID d'objets individuels. Dans la plupart des cas, vous voudrez exécuter une requête sur la collection, comme ainsi:
$ 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 "
}
]
}Pour en savoir plus sur l'utilisation d'objets de sauvegarde et d'interrogation sur Parse Server, consultez la documentation Parse.
Parse fournit des SDK pour toutes les principales plateformes. Reportez-vous au Guide du serveur Parse pour savoir comment connecter votre application à Parse Server.
Une fois que vous avez une meilleure compréhension du fonctionnement du projet, veuillez vous référer au Wiki du serveur Parse pour les guides approfondis pour déployer Parse Server aux principaux fournisseurs d'infrastructure. Lisez la suite pour en savoir plus sur les façons supplémentaires d'exécuter Parse Server.
Nous avons fourni une application Node.js de base qui utilise le module de serveur Parse sur Express et peut être facilement déployé dans divers fournisseurs d'infrastructure:
Vous pouvez également créer une instance de serveur Parse et le monter sur un site Web express nouveau ou existant:
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.' ) ;
} ) ; Pour une liste complète des options disponibles, exécutez parse-server --help ou jetez un œil aux [configurations de serveur Parse] [Server-Options].
Vérifiez la santé du serveur Parse en envoyant une demande au point de terminaison /parse/health .
La réponse ressemble à ceci:
{
"status" : " ok "
}| Valeur | Description |
|---|---|
initialized | Le serveur a été créé mais la méthode start n'a pas encore été appelée. |
starting | Le serveur commence. |
ok | Le serveur a commencé et est en cours d'exécution. |
error | Il y a eu une erreur de démarrage, consultez les journaux pour plus de détails. |
Le serveur d'analyse peut être configuré à l'aide des options suivantes. Vous pouvez les transmettre en tant que paramètres lors de l'exécution d'un parse-server autonome, ou en chargeant un fichier de configuration au format JSON à l'aide parse-server path/to/configuration.json . Si vous utilisez Parse Server sur Express, vous pouvez également les transmettre à l'objet ParseServer comme options.
Pour la liste complète des options disponibles, exécutez parse-server --help ou jetez un œil aux [configurations de serveur Parse] [Server-Options].
appId (requis) - L'ID d'application à héberger avec cette instance de serveur. Vous pouvez utiliser n'importe quelle chaîne arbitraire. Pour les applications migrées, cela devrait correspondre à votre application d'analyse hébergée.masterKey (requis) - La touche maître à utiliser pour l'emporter sur la sécurité ACL. Vous pouvez utiliser n'importe quelle chaîne arbitraire. Gardez-le secret! Pour les applications migrées, cela devrait correspondre à votre application d'analyse hébergée.databaseURI (requis) - La chaîne de connexion pour votre base de données, c'est-à-dire mongodb://user:[email protected]/dbname . Assurez-vous de coder URL votre mot de passe si votre mot de passe a des caractères spéciaux.port - Le port par défaut est 1337, spécifiez ce paramètre pour utiliser un autre port.serverURL - URL sur votre serveur Parse (n'oubliez pas de spécifier http: // ou https: //). Cette URL sera utilisée lors de la réalisation de demandes pour analyser le serveur à partir du code cloud.cloud - Le chemin absolu vers votre fichier Cloud Code main.jspush - Options de configuration pour APNS et GCM Push. Voir le démarrage rapide des notifications push. Les clés client utilisées avec l'analyse ne sont plus nécessaires avec Parse Server. Si vous souhaitez toujours les exiger, peut-être pouvoir refuser l'accès aux clients plus âgés, vous pouvez définir les clés au moment de l'initialisation. La définition de l'une de ces clés nécessitera toutes les demandes pour fournir l'une des clés configurées.
clientKeyjavascriptKeyrestAPIKeydotNetKey| Portée | Données internes | Données en lecture seule (1) | Données personnalisées | Restreint par CLP, ACL | Clé |
|---|---|---|---|---|---|
| Interne | r / w | r / w | r / w | Non | maintenanceKey |
| Maître | - / - | r / - | r / w | Non | masterKey |
| ReadOnlymaster | - / - | r / - | r / - | Non | readOnlyMasterKey |
| Session | - / - | r / - | r / w | Oui | sessionToken |
(1) Parse.Object.createdAt , Parse.Object.updatedAt .
La vérification des adresses e-mail de l'utilisateur et l'activation de la réinitialisation du mot de passe par e-mail nécessitent un adaptateur de messagerie. Il existe de nombreux adaptateurs par e-mail fournis et entretenus par la communauté. Ce qui suit est un exemple de configuration avec un exemple d'adaptateur de messagerie. Voir les [options de serveur Parse] [Options Server] pour plus de détails et une liste complète des options disponibles.
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
}
} ,
} ) ;Adaptateurs d'e-mail officiels maintenus par Parse Platform:
Adaptateurs par e-mail contribué par la communauté:
Définissez une politique de mot de passe et de compte qui répond à vos exigences de sécurité. Ce qui suit est un exemple de configuration. Voir les [options de serveur Parse] [Options Server] pour plus de détails et une liste complète des options disponibles.
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 ,
} ,
} ) ; ATTENTION, il s'agit d'une caractéristique expérimentale qui peut ne pas être appropriée pour la production.
Les itinéraires personnalisés permettent de créer des flux d'utilisateurs avec des pages Web, similaires aux fonctionnalités de réinitialisation de mot de passe et de vérification par e-mail existantes. Les itinéraires personnalisés sont définis avec l'option pages dans la configuration du serveur 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' } ;
}
} ]
}
} L'itinéraire ci-dessus peut être invoqué en envoyant une demande GET à: https://[parseServerPublicUrl]/[parseMount]/[pagesEndpoint]/[appId]/[customRoute]
Le handler reçoit la request et renvoie une page Web custom_page.html du répertoire pages.pagesPath en réponse. L'avantage de la construction d'un itinéraire personnalisé de cette façon est qu'il utilise automatiquement les capacités intégrées de Parse Server, telles que la localisation des pages et les espaces réservés dynamiques.
Les chemins suivants sont déjà utilisés par les fonctionnalités intégrées de Parse Server et ne sont donc pas disponibles pour les itinéraires personnalisés. Les voies personnalisées avec une combinaison identique de path et method sont ignorées.
| Chemin | Méthode HTTP | Fonctionnalité |
|---|---|---|
verify_email | GET | Vérification par e-mail |
resend_verification_email | POST | Vérification par e-mail |
choose_password | GET | réinitialisation du mot de passe |
request_password_reset | GET | réinitialisation du mot de passe |
request_password_reset | POST | réinitialisation du mot de passe |
| Paramètre | Facultatif | Taper | Valeur par défaut | Exemples de valeurs | Variable d'environnement | Description |
|---|---|---|---|---|---|---|
pages | Oui | Object | undefined | - | PARSE_SERVER_PAGES | Les options de pages telles que la réinitialisation du mot de passe et la vérification par e-mail. |
pages.enableRouter | Oui | Boolean | false | - | PARSE_SERVER_PAGES_ENABLE_ROUTER | Est true si le routeur des pages doit être activé; Ceci est requis pour que l'une des options de pages prenne effet. ATTENTION, il s'agit d'une caractéristique expérimentale qui peut ne pas être appropriée pour la production. |
pages.customRoutes | Oui | Array | [] | - | PARSE_SERVER_PAGES_CUSTOM_ROUTES | Les routes personnalisées. Les itinéraires sont ajoutés dans l'ordre où ils sont définis ici, ce qui doit être pris en considération car les demandes de parcours traversent les routes de manière ordonnée. Les itinéraires personnalisés sont traversés après les itinéraires de reconstitution tels que la réinitialisation du mot de passe et la vérification par e-mail. |
pages.customRoutes.method | String | - | GET , POST | - | La méthode HTTP de la route personnalisée. | |
pages.customRoutes.path | String | - | custom_page | - | Le chemin de la route personnalisée. Notez que le même chemin peut être utilisé si la method est différente, par exemple un chemin custom_page peut avoir deux itinéraires, une route GET et POST , qui sera invoquée en fonction de la méthode de demande HTTP. | |
pages.customRoutes.handler | AsyncFunction | - | async () => { ... } | - | Le gestionnaire d'itinéraire qui est invoqué lorsque l'itinéraire correspond à la demande HTTP. Si le gestionnaire ne renvoie pas de page, la demande est répondue avec un 404 Not found. réponse. |
Il est possible de modifier les pages par défaut de l'application et de rediriger l'utilisateur vers un autre chemin ou domaine.
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"
}
} ) Vous pouvez configurer le serveur Parse à l'aide de variables d'environnement:
PORT
PARSE_SERVER_APPLICATION_ID
PARSE_SERVER_MASTER_KEY
PARSE_SERVER_DATABASE_URI
PARSE_SERVER_URL
PARSE_SERVER_CLOUDLe port par défaut est 1337, pour utiliser un port différent définir la variable d'environnement du port:
$ PORT=8080 parse-server --appId APPLICATION_ID --masterKey MASTER_KEY Pour la liste complète des variables d'environnement configurables, exécutez parse-server --help ou jetez un œil à la configuration du serveur Parse.
Tous les adaptateurs officiels sont distribués sous forme de packages dans le cadre de NPM (@Parse).
Certains adaptateurs bien entretenus sont également disponibles sur l'organisation des modules Parse Server.
Vous pouvez également trouver plus d'adaptateurs entretenus par la communauté en recherchant le NPM.
Parse Server permet aux développeurs de choisir parmi plusieurs options lors de l'hébergement de fichiers:
GridFSBucketAdapter - qui est soutenu par MongoDBS3Adapter - qui est soutenu par Amazon S3GCSAdapter - qui est soutenu par Google Cloud StorageFSAdapter - Stockage de fichiers local GridFSBucketAdapter est utilisé par défaut et ne nécessite aucune configuration, mais si vous êtes intéressé à utiliser Amazon S3, le stockage Google Cloud ou le stockage de fichiers local, des informations de configuration supplémentaires sont disponibles dans le guide du serveur Parse.
ATTENTION, il s'agit d'une caractéristique expérimentale qui peut ne pas être appropriée pour la production.
Cette fonctionnalité déduplique les demandes identiques qui sont reçues par Parse Server plusieurs fois, généralement en raison de problèmes de réseau ou de restrictions d'accès aux adaptateurs réseau sur les systèmes d'exploitation mobiles.
Les demandes identiques sont identifiées par leur en-tête de demande X-Parse-Request-Id . Par conséquent, une demande du client doit inclure cet en-tête pour la déduplication à appliquer. Les demandes qui ne contiennent pas cet en-tête ne peuvent pas être dédupliquées et sont traitées normalement par Parse Server. Cela signifie que le déploiement de cette fonctionnalité aux clients est transparent car Parse Server traite toujours les demandes sans cet en-tête lorsque cette fonctionnalité est activée.
Cette fonctionnalité doit être activée du côté client pour envoyer l'en-tête et sur le serveur pour traiter l'en-tête. Reportez-vous aux documents SDK Parse spécifiques pour voir si la fonctionnalité est encore prise en charge.
La déduplication est effectuée uniquement pour la création et la mise à jour d'objets ( POST et PUT les demandes). La déduplication n'est pas effectuée pour la recherche et la suppression d'objets ( GET et DELETE les demandes), car ces opérations sont déjà idempotentes par définition.
let api = new ParseServer({
idempotencyOptions: {
paths: [".*"], // enforce for all requests
ttl: 120 // keep request IDs for 120s
}
}
| Paramètre | Facultatif | Taper | Valeur par défaut | Exemples de valeurs | Variable d'environnement | Description |
|---|---|---|---|---|---|---|
idempotencyOptions | Oui | Object | undefined | Parse_server_experimental_idempotentency_options | Le réglage permet l'application d'idempotence pour les chemins spécifiés. | |
idempotencyOptions.paths | Oui | Array<String> | [] | .* (Tous les chemins, comprend les exemples ci-dessous),functions/.* (toutes les fonctions),jobs/.* (tous les emplois),classes/.* (toutes les classes),functions/.* (toutes les fonctions),users (création / mise à jour des utilisateurs),installations (création d'installation / mise à jour) | Parse_server_experimental_idempotentency_paths | Un tableau de modèles de chemin qui doivent faire correspondre le chemin de demande pour la déduplication de demande à activer. Le chemin de montage ne doit pas être inclus, par exemple pour faire correspondre le chemin de demande /parse/functions/myFunction Spécifiez les functions/myFunction . Une barre oblique de fuite du chemin de demande est ignorée, par exemple, les functions/myFunction correspondent à deux /parse/functions/myFunction et /parse/functions/myFunction/ . |
idempotencyOptions.ttl | Oui | Integer | 300 | 60 (60 secondes) | Parse_server_experimental_idempotentency_ttl | La durée en quelques secondes après quoi un enregistrement de demande est rejetée dans la base de données. On peut s'attendre à ce que les demandes en double des problèmes de réseau arrivent en quelques millisecondes jusqu'à plusieurs secondes. Cette valeur doit être supérieure à 0 . |
Pour utiliser cette fonctionnalité dans Postgres, vous devrez créer un travail CRON à l'aide de pgadmin ou similaire à l'appel de la fonction postgres idempotency_delete_expired_records() qui supprime des enregistrements d'identification expirés. Vous pouvez trouver un exemple de script ci-dessous. Assurez-vous que le script a les mêmes privilèges pour vous connecter à Postgres que Parse Server.
#! /bin/bash
set -e
psql -v ON_ERROR_STOP=1 --username " $POSTGRES_USER " --dbname " $POSTGRES_DB " << - EOSQL
SELECT idempotency_delete_expired_records();
EOSQL
exec " $@ " En supposant que le script ci-dessus est nommé, parse_idempotency_delete_expired_records.sh , un travail cron qui exécute le script toutes les 2 minutes peut ressembler:
2 * * * * /root/parse_idempotency_delete_expired_records.sh > /dev/null 2>&1 ATTENTION, il s'agit d'une caractéristique expérimentale qui peut ne pas être appropriée pour la production.
Les pages personnalisées ainsi que les pages de fonctions (par exemple, réinitialisation du mot de passe, vérification par e-mail) peuvent être localisées avec l'option pages dans la configuration du serveur d'analyse:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
}
} La localisation est obtenue en correspondant à un paramètre locale fourni par la demande avec un contenu de page localisé. Le lieu peut être fourni dans la requête de la demande, le corps ou l'en-tête avec les clés suivantes:
localelocalex-parse-page-param-localePar exemple, un lien de réinitialisation de mot de passe avec le paramètre paramètre dans la requête pourrait ressembler à ceci:
http://example.com/parse/apps/[appId]/request_password_reset?token=[token]&username=[username]&locale=de-AT
pages.pagesPath .pages.customUrls sont définies, même si les URL personnalisées pointent vers les pages du chemin des pages..html sont pris en compte pour la localisation lors de la localisation des pages personnalisées.Les pages peuvent être localisées de deux manières:
Les pages sont localisées en utilisant le fichier correspondant dans la structure du répertoire où les fichiers sont placés dans des sous-répertoires nommés d'après le lieu ou la langue. Le fichier dans le répertoire de base est le fichier par défaut.
Exemple de structure de répertoire:
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 fileLes fichiers sont appariés avec les paramètres régionaux dans l'ordre suivant:
de-AT régionaux ne correspondent pas au fichier dans le dossier de-AT .de-CH Fichier dans le dossier de .Exemple de configuration:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
customUrls : {
passwordReset : 'https://example.com/page.html'
}
}
}Avantages:
Inconvénients:
Les pages sont localisées en ajoutant des espaces réservés dans les fichiers HTML et en fournissant une ressource JSON qui contient les traductions à remplir dans les espaces réservés.
Exemple de structure de répertoire:
root /
├── public / // pages base path
│ ├── example . html // the page containing placeholders
├── private / // folder outside of public scope
│ └── translations . json // JSON resource fileLe fichier de ressources JSON suit de manière lâche la syntaxe i18Next, qui est une syntaxe qui est souvent prise en charge par des plates-formes de traduction, ce qui facilite la gestion des traductions, les exportant pour une utilisation dans Parse Server, et même pour automatiser ce flux de travail.
Exemple de contenu 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! "
}
}
}Exemple de configuration:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
enableLocalization : true ,
localizationJsonPath : './private/localization.json' ,
localizationFallbackLocale : 'en'
}
}Avantages:
Inconvénients:
En plus des paramètres par défaut liés aux fonctionnalités tels que appId et les traductions fournies via la ressource JSON, il est possible de définir les espaces réservés dynamiques personnalisés dans le cadre de la configuration du routeur. Cela fonctionne indépendamment de la localisation et, également si enableLocalization est désactivée.
Exemple de configuration:
const api = new ParseServer ( {
... otherOptions ,
pages : {
enableRouter : true , // Enables the experimental feature; required for localization
placeholders : {
exampleKey : 'exampleValue'
}
}
} Les espaces réservés peuvent également être fournis en fonction ou en fonction asynchrone, avec les paramètres liés aux paramètres locale et d'autres fonctionnalités, pour permettre des valeurs d'espace réservée dynamique:
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
} ;
}
}
} Le paramètre suivant et les clés d'espace réservé sont réservés car ils sont utilisés liés à des fonctionnalités telles que la réinitialisation du mot de passe ou la vérification par e-mail. Ils ne doivent pas être utilisés comme clés de traduction dans la ressource JSON ou comme touches d'espaceurs définies manuellement dans la configuration: appId , appName , email , error , locale , publicServerUrl , token , username .
| Paramètre | Facultatif | Taper | Valeur par défaut | Exemples de valeurs | Variable d'environnement | Description |
|---|---|---|---|---|---|---|
pages | Oui | Object | undefined | - | PARSE_SERVER_PAGES | Les options de pages telles que la réinitialisation du mot de passe et la vérification par e-mail. |
pages.enableRouter | Oui | Boolean | false | - | PARSE_SERVER_PAGES_ENABLE_ROUTER | Est true si le routeur des pages doit être activé; Ceci est requis pour que l'une des options de pages prenne effet. ATTENTION, il s'agit d'une caractéristique expérimentale qui peut ne pas être appropriée pour la production. |
pages.enableLocalization | Oui | Boolean | false | - | PARSE_SERVER_PAGES_ENABLE_LOCALIZATION | Est vrai si les pages doivent être localisées; Cela n'a aucun effet sur les redirections de page personnalisées. |
pages.localizationJsonPath | Oui | String | undefined | ./private/translations.json | PARSE_SERVER_PAGES_LOCALIZATION_JSON_PATH | Le chemin d'accès au fichier JSON pour la localisation; Les traductions seront utilisées pour remplir les espaces réservés des modèles en fonction des paramètres régionaux. |
pages.localizationFallbackLocale | Oui | String | en | en , en-GB , default | PARSE_SERVER_PAGES_LOCALIZATION_FALLBACK_LOCALE | Le lieu de secours pour la localisation si aucune traduction correspondante n'est fournie pour les paramètres régionaux donnés. Ceci n'est pertinent que lors de la fourniture de ressources de traduction via le fichier JSON. |
pages.placeholders | Oui | Object , Function , AsyncFunction | undefined | { exampleKey: 'exampleValue' } | PARSE_SERVER_PAGES_PLACEHOLDERS | Les clés et valeurs de placement qui seront remplies en pages; Cela peut être un objet simple ou une fonction de rappel. |
pages.forceRedirect | Oui | Boolean | false | - | PARSE_SERVER_PAGES_FORCE_REDIRECT | Est true si les réponses doivent toujours être redirigées et jamais contenues, false si le type de réponse doit dépendre du type de demande ( GET DEMAND -> RÉPONSE DE CONTENU; POST DEMAND -> Réponse de redirection). |
pages.pagesPath | Oui | String | ./public | ./files/pages , ../../pages | PARSE_SERVER_PAGES_PAGES_PATH | Le chemin du répertoire des pages; Cela définit également où le point de terminaison statique /apps pointe vers. |
pages.pagesEndpoint | Oui | String | apps | - | PARSE_SERVER_PAGES_PAGES_ENDPOINT | Le point de terminaison de l'API pour les pages. |
pages.customUrls | Oui | Object | {} | { passwordReset: 'https://example.com/page.html' } | PARSE_SERVER_PAGES_CUSTOM_URLS | Les URL aux pages personnalisées |
pages.customUrls.passwordReset | Oui | String | password_reset.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET | L'URL à la page personnalisée pour réinitialiser le mot de passe. |
pages.customUrls.passwordResetSuccess | Oui | String | password_reset_success.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_SUCCESS | L'URL à la page personnalisée pour la réinitialisation du mot de passe -> Succès. |
pages.customUrls.passwordResetLinkInvalid | Oui | String | password_reset_link_invalid.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_LINK_INVALID | L'URL vers la page personnalisée pour réinitialiser le mot de passe -> lien invalide. |
pages.customUrls.emailVerificationSuccess | Oui | String | email_verification_success.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SUCCESS | L'URL à la page personnalisée pour la vérification par e-mail -> Succès. |
pages.customUrls.emailVerificationSendFail | Oui | String | email_verification_send_fail.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_FAIL | L'URL à la page personnalisée pour la vérification par e-mail -> Lien Envoi FAIL. |
pages.customUrls.emailVerificationSendSuccess | Oui | String | email_verification_send_success.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_SUCCESS | L'URL vers la page personnalisée pour la vérification par e-mail -> Rendez le lien -> Succès. |
pages.customUrls.emailVerificationLinkInvalid | Oui | String | email_verification_link_invalid.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_INVALID | L'URL vers la page personnalisée pour la vérification par e-mail -> lien invalide. |
pages.customUrls.emailVerificationLinkExpired | Oui | String | email_verification_link_expired.html | - | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_EXPIRED | L'URL vers la page personnalisée pour la vérification par e-mail -> Lien a expiré. |
Le serveur d'analyse sera, par défaut, log:
Les journaux sont également visibles dans le tableau de bord d'analyse.
Vous voulez enregistrer chaque demande et réponse? Définissez la variable d'environnement VERBOSE lors du démarrage parse-server . Utilisation: - VERBOSE='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Vous voulez que les journaux soient placés dans un dossier différent? Passez la variable d'environnement PARSE_SERVER_LOGS_FOLDER lors du démarrage parse-server . Utilisation: - PARSE_SERVER_LOGS_FOLDER='<path-to-logs-folder>' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Vous voulez enregistrer des niveaux spécifiques? Passez le paramètre logLevel lors du démarrage parse-server . Utilisation: - parse-server --appId APPLICATION_ID --masterKey MASTER_KEY --logLevel LOG_LEVEL
Vous voulez des journaux d'erreur JSON délimités de ligne (pour la consommation par CloudWatch, Google Cloud Logging, etc.)? Passez la variable d'environnement JSON_LOGS lors du démarrage parse-server . Utilisation: - JSON_LOGS='1' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY
Voir le plan de dépréciation pour un aperçu des dépréciations et des changements de rupture prévus.
Les requêtes en direct sont destinées à être utilisées dans des applications réactives en temps réel, où l'utilisation du paradigme de requête traditionnel pourrait causer plusieurs problèmes, comme un temps de réponse accru et une utilisation élevée du réseau et du serveur. Les requêtes en direct doivent être utilisées dans les cas où vous devez mettre à jour en permanence une page avec de nouvelles données provenant de la base de données, qui se produit souvent dans (mais sans s'y limiter) des jeux en ligne, de la messagerie des clients et des listes de tâches partagées.
Jetez un œil au Guide de requête en direct, au guide de configuration du serveur de requête en direct et aux spécifications du protocole de requête en direct. Vous pouvez configurer un serveur autonome ou plusieurs instances d'évolutivité (recommandée).
GraphQL, développé par Facebook, est une requête de données open source et un langage de manipulation pour les API. En plus de l'API REST traditionnelle, Parse Server génère automatiquement une API GraphQL en fonction de votre schéma d'application actuel. Parse Server vous permet également de définir vos requêtes et mutations GraphQL personnalisées, dont les résolveurs peuvent être liés à vos fonctions de code cloud.
La façon la plus simple d'exécuter l'API Parse GraphQL est via la 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 --mountPlaygroundAprès avoir commencé le serveur, vous pouvez visiter http: // localhost: 1337 / terrain de jeu dans votre navigateur pour commencer à jouer avec votre API GraphQL.
Remarque: N'utilisez pas d'option - MountPlayground en production. Parse Dashboard a un terrain de jeu GraphQL intégré et c'est l'option recommandée pour les applications de production.
Vous pouvez également exécuter l'API Parse GraphQL dans un conteneur 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$ 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 Remarque: Si vous souhaitez utiliser le code cloud, ajoutez -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js à la commande ci-dessus. Assurez-vous que main.js est dans le répertoire cloud-code-vol avant de démarrer le serveur d'analyse.
Après avoir commencé le serveur, vous pouvez visiter http: // localhost: 1337 / terrain de jeu dans votre navigateur pour commencer à jouer avec votre API GraphQL.
Remarque: N'utilisez pas d'option - MountPlayground en production. Parse Dashboard a un terrain de jeu GraphQL intégré et c'est l'option recommandée pour les applications de production.
Vous pouvez également monter l'API GraphQL dans une application Express.js avec l'API REST ou SOLO. Vous devez d'abord créer un nouveau projet et installer les dépendances requises:
$ mkdir my-app
$ cd my-app
$ npm install parse-server express --save Ensuite, créez un fichier index.js avec le contenu suivant:
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' ) ;
} ) ;Et enfin commencer votre application:
$ npx mongodb-runner start
$ node index.jsAprès avoir commencé l'application, vous pouvez visiter http: // localhost: 1337 / terrain de jeu dans votre navigateur pour commencer à jouer avec votre API GraphQL.
Remarque: ne montez pas le terrain de jeu GraphQL en production. Parse Dashboard a un terrain de jeu GraphQL intégré et c'est l'option recommandée pour les applications de production.
Exécutez ce qui suit:
query Health {
health
}Vous devriez recevoir la réponse suivante:
{
"data" : {
"health" : true
}
} Étant donné que votre application n'a pas encore de schéma, vous pouvez utiliser la mutation createClass pour créer votre première classe. Exécutez ce qui suit:
mutation CreateClass {
createClass (
name : " GameScore "
schemaFields : {
addStrings : [{ name : " playerName " }]
addNumbers : [{ name : " score " }]
addBooleans : [{ name : " cheatMode " }]
}
) {
name
schemaFields {
name
__typename
}
}
}Vous devriez recevoir la réponse suivante:
{
"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 a appris de la première classe que vous avez créée et maintenant vous avez la classe GameScore dans votre schéma. Vous pouvez maintenant commencer à utiliser les opérations générées automatiquement!
Exécutez ce qui suit pour créer votre premier objet:
mutation CreateGameScore {
createGameScore (
fields : {
playerName : " Sean Plott "
score : 1337
cheatMode : false
}
) {
id
updatedAt
createdAt
playerName
score
cheatMode
ACL
}
}Vous devriez recevoir une réponse similaire à ceci:
{
"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
}
}
}Vous pouvez également exécuter une requête vers cette nouvelle classe:
query GameScores {
gameScores {
results {
id
updatedAt
createdAt
playerName
score
cheatMode
ACL
}
}
}Vous devriez recevoir une réponse similaire à ceci:
{
"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
}
]
}
}
}Parse GraphQL Server vous permet de créer un schéma GraphQL personnalisé avec ses propres requêtes et mutations à fusionner avec les possessions automatique. Vous pouvez résoudre ces opérations à l'aide de vos fonctions de code cloud ordinaires.
Pour commencer à créer votre schéma personnalisé, vous devez coder un fichier schema.graphql et initialiser le serveur Parse avec --graphQLSchema et --cloud Options:
$ 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 Utilisez le code ci-dessous pour vos fichiers schema.graphql et main.js Redémarrez ensuite votre serveur d'analyse.
# schema.graphql
extend type Query {
hello : String ! @resolve
} // main.js
Parse . Cloud . define ( 'hello' , async ( ) => {
return 'Hello world!' ;
} ) ;Vous pouvez maintenant exécuter votre requête personnalisée à l'aide de GraphQL Playground:
query {
hello
}Vous devriez recevoir la réponse ci-dessous:
{
"data" : {
"hello" : " Hello world! "
}
}Le guide Parse GraphQL est une très bonne source pour apprendre à utiliser l'API PARSE GraphQL.
Vous avez également un outil très puissant dans votre terrain de jeu GraphQL. Veuillez regarder le côté droit de votre terrain de jeu GraphQL. Vous verrez les documents DOCS et SCHEMA . Ils sont automatiquement générés en analysant votre schéma d'application. Veuillez vous référer à eux et en savoir plus sur tout ce que vous pouvez faire avec votre API GraphQL Parse.
De plus, la section GraphQL Learn est une très bonne source pour en savoir plus sur la puissance de la langue GraphQL.
Veuillez consulter le guide de contribution.
Ce projet existe grâce à toutes les personnes qui contribuent ... nous aimerions voir votre visage sur cette liste!
Soutenez ce projet en devenant un sponsor. Votre logo apparaîtra ici avec un lien vers votre site Web. Devenez sponsor!
Soutenez-nous avec un don mensuel et nous aidez à poursuivre nos activités. Devenez un bailleur de fonds!
[server-options] http://parseplatform.org/parse-server/api/release/parseserveroptions.html
