Parse Server

Контейнер (#docker-container)

• Сохранение объекта (#saving-an-object).
• Подключение SDK (#connect-an-sdk).

Запуск Parse Server в другом месте (#running-parse-server-elsewhere)

• Пример приложения (#sample-application).
• Parse Server + Express (#parse-server--express).

Состояние сервера Parse (#parse-server-health)

• Значения статуса (#status-values).

Конфигурация (#configuration)

• Основные параметры (#basic-options).
• Параметры клиентского ключа (#client-key-options).
• Области доступа (#access-scopes).
• Проверка электронной почты и сброс пароля (#email-verification-and-password-reset).
• Политика паролей и учётных записей (#password-and-account-policy).
• Пользовательские маршруты (#custom-routes):
  • пример (#example);
  • зарезервированные пути (#reserved-paths);
  • параметры (#parameters).
• Пользовательские страницы (#custom-pages).
• Использование переменных среды (#using-environment-variables).
• Доступные адаптеры (#available-adapters).
• Настройка файловых адаптеров (#configuring-file-adapters).
• Обеспечение идемпотентности (#idempotency-enforcement).
• Локализация (#localization):
  • страницы (#pages);
    • локализация с помощью структуры каталогов (#localization-with-directory-structure);
    • локализация с использованием JSON-ресурса (#localization-with-json-resource);
    • динамические заполнители (#dynamic-placeholders);
    • зарезервированные ключи (#reserved-keys);
    • параметры (#parameters-1).
• Ведение журнала (#logging).

Устаревания (#deprecations).

Live Query (#live-query).

GraphQL (#graphql)

• Запуск (#running):
  • использование CLI (#using-the-cli);
  • использование Docker (#using-docker);
  • использование Express.js (#using-expressjs).
• Проверка работоспособности API (#checking-the-api-health).
• Создание вашего первого класса (#creating-your-first-class).
• Использование автоматически сгенерированных операций (#using-automatically-generated-operations).
• Кастомизация вашей схемы GraphQL (#customizing-your-graphql-schema).
• Дополнительная информация (#learning-more).

Внесение вклада (#contributing).

Участники (#contributors).

Спонсоры (#sponsors).

Поддержавшие проект (#backers).

Разновидности и ветки

Parse Server доступен в различных вариантах на разных ветках:

• основные ветки — [release][log_release], [beta][log_beta] и [alpha][log_alpha]. Подробности см. в обзоре изменений (CHANGELOG.md).
• долгосрочная поддержка (LTS) предоставляется для предыдущей основной версии Parse Server. Например, Parse Server 5.x будет получать обновления безопасности до тех пор, пока Parse Server 6.x не заменит Parse Server 7.x и не станет новой версией LTS. В то время как текущая основная версия публикуется на ветке release, версия LTS публикуется на ветке release-#.x.x, например release-5.x.x для ветки Parse Server 5.x LTS.

Долгосрочная поддержка

Долгосрочная поддержка (LTS) предназначена для предыдущей основной версии Parse Server. Мы предоставляем обновления безопасности для LTS-версии, но основное внимание уделяем разработке текущей основной версии и подготовке следующего основного выпуска. Поэтому мы можем оставить некоторые уязвимости на усмотрение сообщества. Чтобы узнать о текущих открытых уязвимостях для этой LTS-ветки, ищите запросы на вытягивание с конкретной базой LTS.

Начало работы

Самый быстрый и простой способ начать работу — запустить MongoDB и Parse Server локально.

Запуск Parse Server

Перед началом убедитесь, что вы установили:

• NodeJS, который включает npm;
• MongoDB или PostgreSQL (с PostGIS 2.2.0 или выше);
• опционально Docker.

Совместимость

Node.js

Parse Server постоянно тестируется с последними выпусками Node.js для обеспечения совместимости. Мы следуем политике [долгосрочной поддержки Node.js]. План](https://github.com/nodejs/Release) и тестирование только с версиями, которые официально поддерживаются и не достигли даты окончания поддержки.

MongoDB

Parse Server постоянно тестируется с последними выпусками MongoDB для обеспечения совместимости. Мы следуем графику поддержки MongoDB и графику жизненного цикла MongoDB и тестируем только версии, которые официально поддерживаются и не достигли даты окончания поддержки. «Быстрые выпуски» MongoDB игнорируются, поскольку они считаются предварительными версиями следующей основной версии.

PostgreSQL

Parse Server постоянно тестируется с последними выпусками PostgreSQL и PostGIS для обеспечения совместимости, используя образы Docker PostGIS. Мы следуем графику поддержки PostgreSQL и графику поддержки PostGIS и тестируем только те версии, которые официально поддерживаются и не достигли даты окончания поддержки. Из-за обширной продолжительности поддержки PostgreSQL в 5 лет Parse Server прекращает поддержку примерно за 2 года до официальной даты окончания поддержки.

Локально

$ 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 Server

$ 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

Примечание: Если вы хотите использовать Cloud Code, добавьте -v cloud-code-vol:/parse-server/cloud --cloud /parse-server/cloud/main.js в команду выше. Перед запуском Parse Server убедитесь, что main.js находится в каталоге cloud-code-vol.

Вы можете использовать любую произвольную строку в качестве идентификатора приложения и мастер-ключа. Они будут использоваться вашими клиентами для аутентификации на сервере Parse.

Вот и всё! Теперь у вас есть автономная версия сервера Parse на вашем компьютере.

Используя удалённый MongoDB? Передайте параметр --databaseURI DATABASE_URI при запуске parse-server. Узнайте больше о настройке сервера Parse здесь. Для получения полного списка доступных опций запустите parse-server. Сохранение объекта

Теперь, когда вы запустили Parse Server, пришло время сохранить ваш первый объект. Мы будем использовать REST API (http://docs.parseplatform.org/rest/guide), но вы можете легко сделать то же самое, используя любой из Parse SDKs (http://parseplatform.org/#sdks). Выполните следующее:

$ 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

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

Однако отслеживание отдельных идентификаторов объектов не является идеальным решением. В большинстве случаев вы захотите выполнить запрос по коллекции следующим образом:

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

// Ответ предоставит все соответствующие объекты в массиве `results`:
{
  "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 Server, ознакомьтесь с документацией Parse (http://docs.parseplatform.org).

Подключение SDK

Parse предоставляет SDK для всех основных платформ. Обратитесь к руководству Parse Server, чтобы узнать, как подключить ваше приложение к Parse Server (https://docs.parseplatform.org/parse-server/guide/#using-parse-sdks-with-parse-server).

Запуск Parse Server в другом месте

Как только вы лучше поймёте, как работает проект, обратитесь к вики Parse Server (https://github.com/parse-community/parse-server-wiki) за подробными руководствами по развёртыванию Parse Server у основных поставщиков инфраструктуры. Читайте дальше, чтобы узнать больше о дополнительных способах запуска Parse Server.

Пример приложения

Мы предоставили базовое приложение Node.js (https://github.com/parse-community/parse-server-example), которое использует модуль Parse Server на Express и может быть легко развёрнуто на различных поставщиках инфраструктуры:

• Heroku и mLab (https://devcenter.heroku.com/articles/deploying-a-parse-server-to-heroku)
• AWS и Elastic Beanstalk (http://mobile.awsblog.com/post/TxCD57GZLM2JR/How-to-set-up-Parse-Server-on-AWS-using-AWS-Elastic-Beanstalk)
• Google App Engine (https://medium.com/@justinbeckwith/deploying-parse-server-to-google-app-engine-6bc0b7451d50)
• Microsoft Azure (https://azure.microsoft.com/en-us/blog/azure-welcomes-parse-developers/)
• SashiDo (https://blog.sashido.io/tag/migration/)
• Digital Ocean (https://www.digitalocean.com/community/tutorials/how-to-run-parse-server-on-ubuntu-14-04)
• Pivotal Web Services (https://github.com/cf-platform-eng/pws-parse-server)
• Back4app (https://www.back4app.com/docs/get-started/welcome)
• Glitch (https://glitch.com/edit/#!/parse-server)
• Flynn (https://flynn.io/blog/parse-apps-on-flynn)

Parse Server + Express

Вы также можете создать экземпляр Parse Server и подключить его к новому или существующему веб-сайту 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' // Не забудьте изменить на https, если необходимо
});

// Запускаем сервер
await server.start();

// Служим API Parse на префиксе URL /parse
app.use('/parse', server.app);

app.listen(1337, function() {
  console.log('parse-server-example работает на порту 1337.');
});

Для получения полного списка доступных опций запустите parse-server --help или ознакомьтесь с Конфигурациями сервера Parse.

Состояние сервера Parse

Проверьте состояние сервера Parse, отправив запрос на конечную точку /parse/health.

Ответ выглядит следующим образом:

{
  "status": "ok"
}

Значения статуса

Конфигурация

Сервер Parse можно настроить с помощью следующих параметров. Вы можете передать их как параметры при запуске автономного parse-сервера или загрузив файл конфигурации в формате JSON с помощью parse-сервер путь/к/конфигурации.json. Если вы используете сервер Parse на Express, вы также можете передать эти параметры объекту ParseServer в качестве опций.

Полный список доступных опций можно получить, запустив parse-server --help, или ознакомиться с Конфигурациями сервера Parse.

Основные опции

• appId (обязательно) — идентификатор приложения для размещения в этом экземпляре сервера. Можно использовать любую произвольную строку. Для перенесённых приложений он должен соответствовать вашему размещённому приложению Parse.
• masterKey (обязательно) — мастер-ключ для переопределения безопасности ACL. Можно использовать любую произвольную строку. Храните его в секрете! Для перенесённых приложений он должен соответствовать вашему размещённому приложению Parse.
• databaseURI (обязательно) — строка подключения к вашей базе данных, например, mongodb://user:pass@host.com/dbname. Обязательно URL-кодируйте свой пароль, если ваш пароль содержит специальные символы.
• port — порт по умолчанию — 1337. Укажите этот параметр, чтобы использовать другой порт.
• serverURL — URL вашего сервера Parse (не забудьте указать http:// или https://). Этот URL будет использоваться при отправке запросов на сервер Parse из облачного кода.
• cloud — абсолютный путь к файлу main.js вашего облачного кода.
• push — параметры конфигурации для APNS и GCM push. См. Быстрый старт уведомлений Push.

Опции клиентского ключа

Клиентские ключи, используемые с Parse, больше не нужны с сервером Parse. Если вы хотите продолжать их использовать, возможно, чтобы иметь возможность отказывать в доступе старым клиентам, вы можете установить ключи во время инициализации. Установка любого из этих ключей потребует от всех запросов предоставления одного из настроенных ключей.

• clientKey
• javascriptKey
• restAPIKey
• dotNetKey

Области доступа

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

Email Verification and Password Reset

Проверка адресов электронной почты пользователей и сброс пароля через электронную почту требуют наличия адаптера электронной почты. Существует множество адаптеров электронной почты, предоставляемых и поддерживаемых сообществом. Ниже приведён пример конфигурации с использованием примера адаптера электронной почты. Более подробную информацию и полный список доступных опций см. в разделе «Параметры сервера Parse» (https://parseplatform.org/parse-server/api/master/ParseServerOptions.html).

const server = ParseServer({
  ...otherOptions,

  // Включить проверку электронной почты пользователя
  verifyUserEmails: true,

  // Установить срок действия токена для проверки электронной почты равным 2 часам
  emailVerifyTokenValidityDuration: 2 * 60 * 60,

  // Задать адаптер электронной почты
  emailAdapter: {
    module: 'example-mail-adapter',
    options: {
      // Дополнительные опции адаптера
      ...mailAdapterOptions
    }
  },
});

Официальные адаптеры электронной почты, поддерживаемые платформой Parse:

• parse-server-api-mail-adapter (https://github.com/parse-community/parse-server-api-mail-adapter) (локализация, шаблоны, универсальная поддержка любого провайдера электронной почты);

Адаптеры электронной почты от сообщества:

• parse-smtp-template (https://www.npmjs.com/package/parse-smtp-template) (локализация, шаблоны);
• parse-server-postmark-adapter (https://www.npmjs.com/package/parse-server-postmark-adapter);
• parse-server-sendgrid-adapter (https://www.npmjs.com/package/parse-server-sendgrid-adapter);
• parse-server-mandrill-adapter (https://www.npmjs.com/package/parse-server-mandrill-adapter);
• parse-server-simple-ses-adapter (https://www.npmjs.com/package/parse-server-simple-ses-adapter);
• parse-server-mailgun-adapter-template (https://www.npmjs.com/package/parse-server-mailgun-adapter-template);
• parse-server-sendinblue-adapter (https://www.npmjs.com/package/parse-server-sendinblue-adapter);
• parse-server-mailjet-adapter (https://www.npmjs.com/package/parse-server-mailjet-adapter);
• simple-parse-smtp-adapter (https://www.npmjs.com/package/simple-parse-smtp-adapter);
• parse-server-generic-email-adapter (https://www.npmjs.com/package/parse-server-generic-email-adapter).

Политика паролей и учётных записей

Установите политику паролей и учётных записей, соответствующую вашим требованиям безопасности. Ниже приведён пример конфигурации. Более подробную информацию и полный список доступных опций см. в разделе «Параметры сервера Parse» (https://parseplatform.org/parse-server/api/master/ParseServerOptions.html).

const server = ParseServer({
  ...otherOptions,

  // Политика блокировки учётной записи
  accountLockout: {
    // Блокировать учётную запись на 5 минут
    duration: 5,
    // Блокировать учётную запись после 3 неудачных попыток входа
    threshold: 3,
    // Разблокировать учётную запись после успешного сброса пароля
    unlockOnPasswordReset: true,
  },

  // Политика паролей
  passwordPolicy: {
    // Требовать пароль длиной не менее 8 символов, содержащий хотя бы одну строчную букву, одну прописную букву и одну цифру
    validatorPattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})/,
    // Запретить использование имени пользователя в качестве части пароля
    doNotAllowUsername: true,
    // Не разрешать повторное использование последних 5 паролей при установке нового пароля
    maxPasswordHistory: 5,
  }
});

Пользовательские маршруты

Внимание, это экспериментальная функция, которая может не подходить для производственной среды.

Пользовательские маршруты позволяют создавать пользовательские потоки с веб-страницами, подобно существующим функциям сброса пароля и проверки электронной почты. Пользовательские маршруты определяются с помощью параметра pages в конфигурации сервера Parse.

Пример

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

  pages: {
    enableRouter: true, // Включает экспериментальную функцию; требуется для пользовательских маршрутов
    customRoutes: [{
      method: 'GET',
      path: 'custom_route',
      handler: async request => {
        // Пользовательская логика
        // ...
        // Затем, в зависимости от результата, вернуть HTML-файл в ответ
        return { file: 'custom_page.html' };
      }
    }]
  }
}

Приведённый выше маршрут может быть... Вызвано отправкой запроса GET по адресу: https://[parseServerPublicUrl]/[parseMount]/[pagesEndpoint]/[appId]/[customRoute]

Обработчик (handler) получает запрос (request) и возвращает веб-страницу custom_page.html из каталога pages.pagesPath в качестве ответа. Преимущество создания пользовательского маршрута таким способом заключается в том, что он автоматически использует встроенные возможности Parse Server, такие как локализация страниц и динамические заполнители.

Зарезервированные пути

Следующие пути уже используются встроенными функциями Parse Server и поэтому недоступны для пользовательских маршрутов. Пользовательские маршруты с идентичным сочетанием path и method игнорируются.

Параметры

Custom Pages

Можно изменить стандартные страницы приложения и перенаправить пользователя на другой путь или домен.

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"
  }
})

Using Environment Variables

Вы можете настроить сервер Parse с помощью переменных среды:

PORT
PARSE_SERVER_APPLICATION_ID
PARSE_SERVER_MASTER_KEY
PARSE_SERVER_DATABASE_URI
PARSE_SERVER_URL
PARSE_SERVER_CLOUD

По умолчанию порт равен 1337. Чтобы использовать другой порт, установите переменную среды PORT:

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

Полный список настраиваемых переменных среды можно получить, выполнив команду parse-server --help или обратившись к Parse Server Configuration.

Available Adapters

Все официальные адаптеры распространяются в виде пакетов с ограниченной областью действия на npm (@parse).

Некоторые хорошо поддерживаемые адаптеры также доступны в организации Parse Server Modules.

Также вы можете найти больше адаптеров, поддерживаемых сообществом, выполнив поиск на npm.

Configuring File Adapters

Сервер Parse позволяет разработчикам выбирать из нескольких вариантов при размещении файлов:

• GridFSBucketAdapter, который поддерживается MongoDB;
• S3Adapter, который поддерживается Amazon S3;
• GCSAdapter, который поддерживается Google Cloud Storage;
• FSAdapter — локальное хранилище файлов.

GridFSBucketAdapter используется по умолчанию и не требует настройки, но если вы хотите использовать Amazon S3, Google Cloud Storage или локальное хранилище файлов, дополнительную информацию о конфигурации можно найти в руководстве Parse Server.

Idempotency Enforcement

Внимание, это экспериментальная функция, которая может не подходить для производственной среды.

Эта функция дедуплицирует идентичные запросы, которые несколько раз поступают на сервер Parse, обычно из-за проблем с сетью или ограничений доступа сетевого адаптера на мобильных операционных системах.

Идентичные запросы определяются по их заголовку запроса X-Parse-Request-Id. Поэтому клиентский запрос должен включать этот заголовок, чтобы применялась дедупликация. Запросы, не содержащие этот заголовок, не могут быть дедуплицированы и обрабатываются сервером Parse обычным образом. Это означает, что развёртывание этой функции на клиентах происходит незаметно, поскольку сервер Parse всё равно обрабатывает запросы без этого заголовка, когда эта функция включена.

Эту функцию необходимо включить на стороне клиента для отправки заголовка и на сервере для обработки заголовка. Обратитесь к документации конкретного 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 | Настройка включает обеспечение идемпотентности для указанных путей.                                                                                                                                                                                                                                                                                                                                                                                |
| `idempotencyOptions.paths` | да      | `Array<String>` | `[]`          | `.*` (все пути, включая примеры ниже), <br>`functions/.*` (все функции), <br>`jobs/.*` (все задания), <br>`classes/.*` (все классы), <br>`functions/.*` (все функции), <br>`users` (создание / обновление пользователя), <br>`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`. **Постгрес**

Чтобы использовать эту функцию в Постгресе, вам нужно создать задание cron с помощью [pgAdmin](https://www.pgadmin.org/docs/pgadmin4/development/pgagent_jobs.html) или аналогичного инструмента для вызова функции Postgres `idempotency_delete_expired_records()`, которая удаляет устаревшие записи идемпотентности. Вы можете найти пример сценария ниже. Убедитесь, что сценарий имеет те же привилегии для входа в Постгрес, что и Parse Server.

```bash
#!/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, // Включает экспериментальную функцию; требуется для локализации,
    enableLocalization: true,
  }
}

Локализация достигается путём сопоставления параметра запроса locale с локализованным содержимым страницы. Параметр locale может быть предоставлен в запросе, теле или заголовке со следующими ключами:

• запрос: locale;
• тело: locale;
• заголовок: x-parse-page-param-locale.

Например, ссылка для сброса пароля с параметром locale в запросе может выглядеть так:

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

• Локализация доступна только для страниц в каталоге pages, заданном с помощью pages.pagesPath.
• Локализация для страниц функций (например, сброса пароля, проверки электронной почты) отключена, если установлены pages.customUrls, даже если пользовательские URL указывают на страницы в пределах пути к страницам.
• При локализации пользовательских страниц учитываются только файлы .html.

Страницы можно локализовать двумя способами:

Локализация с использованием структуры каталогов

Страницы локализуются с помощью соответствующих файлов в структуре каталогов, где файлы размещаются во вложенных каталогах, названных в честь локали или языка. Файл в базовом каталоге является файлом по умолчанию.

Пример структуры каталога:

root/
├── public/                  // базовый путь к страницам
│   ├── example.html         // файл по умолчанию
│   └── de/                  // папка языка de
│   │   └── example.html     // файл, локализованный для de
│   └── de-AT/               // папка локали de-AT
│   │   └── example.html     // файл, локализованный для de-AT

Файлы сопоставляются с локалью в следующем порядке:

1. Соответствие локали, например, локаль de-AT соответствует файлу в папке de-AT.
2. Языковое соответствие, например, локаль de-CH соответствует файлу в папке de.
3. По умолчанию возвращается файл из базовой папки.

Пример конфигурации:

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

  pages: {
    enableRouter: true, // включает экспериментальную функцию; требуется для локализации,
    enableLocalization: true,
    customUrls: {
      passwordReset: 'https://example.com/page.html'
    }
  }
}

Плюсы:

• Все файлы являются полными по содержанию и могут быть легко открыты и просмотрены путём просмотра файла в браузере.

Минусы:

• В большинстве случаев локализованная страница лишь немного отличается от страницы по умолчанию, что может привести к большому объёму дублирующегося кода, который трудно поддерживать.

Локализация с использованием ресурса JSON

Страницы локализуются путём добавления заполнителей в файлы HTML и предоставления ресурса JSON, содержащего переводы для заполнения заполнителей.

Пример структуры каталогов:

root/
├── public/                  // базовый путь к страницам
│   ├── example.html         // страница, содержащая заполнители
├── private/                 // папка вне области public
│   └── translations.json    // JSON | Да | Объект | {} | {passwordReset: 'https://example.com/page.html'} | PARSE_SERVER_PAGES_CUSTOM_URLS | URL-адреса пользовательских страниц |
| --- | ------- | -------- | ----------------------------------------- | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| pages.customUrls.passwordReset | Да | Строка | password_reset.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET | URL пользовательской страницы для сброса пароля |
| pages.customUrls.passwordResetSuccess | Да | Строка | password_reset_success.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_SUCCESS | URL пользовательской страницы успеха после сброса пароля |
| pages.customUrls.passwordResetLinkInvalid | Да | Строка | password_reset_link_invalid.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_PASSWORD_RESET_LINK_INVALID | URL пользовательской страницы при недействительной ссылке для сброса пароля |
| pages.customUrls.emailVerificationSuccess | Да | Строка | email_verification_success.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SUCCESS | URL пользовательской страницы после успешной верификации по электронной почте |
| pages.customUrls.emailVerificationSendFail | Да | Строка | email_verification_send_fail.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_FAIL | URL пользовательской страницы в случае сбоя отправки ссылки для верификации по электронной почте |
| pages.customUrls.emailVerificationSendSuccess | Да | Строка | email_verification_send_success.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_SEND_SUCCESS | URL пользовательской страницы в случае успешной повторной отправки ссылки для верификации по электронной почте |
| pages.customUrls.emailVerificationLinkInvalid | Да | Строка | email_verification_link_invalid.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_INVALID | URL пользовательской страницы при недействительной ссылке верификации по электронной почте |
| pages.customUrls.emailVerificationLinkExpired | Да | Строка | email_verification_link_expired.html | — | PARSE_SERVER_PAGES_CUSTOM_URL_EMAIL_VERIFICATION_LINK_EXPIRED | URL пользовательской страницы при просроченной ссылке верификации по электронной почте. | **ИСПОЛЬЗОВАНИЕ PARSE-SERVER С EXPRESS.JS**

После запуска сервера вы можете посетить http://localhost:1337/playground в браузере, чтобы начать работу с GraphQL API.

*Примечание:* Не используйте опцию --mountPlayground в рабочей среде. Parse Dashboard имеет встроенную игровую площадку GraphQL и является рекомендуемым вариантом для производственных приложений.

### Использование Express.js

Вы также можете подключить GraphQL API в приложении Express.js вместе с REST API или отдельно. Сначала необходимо создать новый проект и установить необходимые зависимости:

```bash
$ 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); // (Необязательно) Монтирует REST API
parseGraphQLServer.applyGraphQL(app); // Монтирует GraphQL API
parseGraphQLServer.applyPlayground(app); // (Необязательно) Монтирует игровую площадку GraphQL — не использовать в рабочей среде

await parseServer.start();
app.listen(1337, function() {
  console.log('REST API работает на http://localhost:1337/parse');
  console.log('GraphQL API работает на http://localhost:1337/graphql');
  console.log('Игровая площадка GraphQL работает на http://localhost:1337/playground');
});

И, наконец, запустите приложение:

$ npx mongodb-runner start
$ node index.js

После запуска приложения вы можете посетить http://localhost:1337/playground в вашем браузере, чтобы начать работать с вашим 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` в вашей схеме. Теперь вы можете начать использовать автоматически сгенерированные операции!

Выполните следующее, чтобы создать свой первый объект:

```graphql
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
        }
      ]
    }
  }
}
## Настройка вашей схемы GraphQL

Parse GraphQL Server позволяет вам создать пользовательскую схему GraphQL с собственными запросами и мутациями, которые будут объединены с автоматически сгенерированными. Вы можете разрешить эти операции, используя свои обычные функции облачного кода.

Чтобы начать создавать свою пользовательскую схему, вам нужно написать файл `schema.graphql` и инициализировать Parse Server с параметрами `--graphQLSchema` и `--cloud`:

```bash
$ 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. Затем перезапустите ваш Parse Server.

# 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 — это очень хороший источник для изучения того, как использовать API Parse GraphQL.

У вас также есть очень мощный инструмент внутри вашей GraphQL Playground. Пожалуйста, посмотрите на правую сторону вашей GraphQL Playground. Вы увидите меню DOCS и SCHEMA, которые автоматически генерируются путём анализа схемы вашего приложения. Пожалуйста, обратитесь к ним и узнайте больше обо всём, что можно сделать с помощью вашего Parse GraphQL API.

Кроме того, раздел обучения GraphQL является очень хорошим источником для более глубокого изучения возможностей языка GraphQL.

Вклад

Пожалуйста, ознакомьтесь с Руководством по внесению вклада.

Участники

Этот проект существует благодаря всем людям, которые вносят свой вклад... мы хотели бы видеть ваше лицо в этом списке!

Спонсоры

Поддержите этот проект, став спонсором. Ваш логотип будет отображаться здесь со ссылкой на ваш веб-сайт. Станьте спонсором!

<img