There are a few areas where Parse Server does not provide compatibility with the original Parse.com hosted backend.
Parse Analytics is not supported. We recommend sending analytics to another similar service like Mixpanel or Google Analytics.
By default, only an application ID is needed to authenticate with Parse Server. The base configuration that comes with the one-click deploy options does not require authenticating with any other types of keys. Therefore, specifying client keys on Android or iOS is not needed.
Hosted Parse applications can turn off client class creation in their settings. Client Class Creation can be disabled by a configuration flag on parse-server.
You will likely need to make several changes to your Cloud Code to port it to Parse Server.
Each Cloud Code request is now handled by the same instance of Parse Server, therefore there is no longer a concept of a "current user" constrained to each Cloud Code request. If your code uses Parse.User.current(), you should use request.user instead. If your Cloud function relies on queries and other operations being performed within the scope of the user making the Cloud Code request, you will need to pass the user's sessionToken as a parameter to the operation in question.
Consider an messaging app where every Message object is set up with an ACL that only provides read-access to a limited set of users, say the author of the message and the recipient. To get all the messages sent to the current user you may have a Cloud function similar to this one:
// Parse.com Cloud Code
Parse.Cloud.define('getMessagesForUser', async (request) => {
const user = Parse.User.current();
const query = new Parse.Query('Messages');
query.equalTo('recipient', user);
const messages = await query.find();
return messages;
});If this function is ported over to Parse Server without any modifications, you will first notice that your function is failing to run because Parse.User.current() is not recognized. If you replace Parse.User.current() with request.user, the function will run successfully but you may still find that it is not returning any messages at all. That is because query.find() is no longer running within the scope of request.user and therefore it will only return publicly-readable objects.
To make queries and writes as a specific user within Cloud Code, you need to pass the user's sessionToken as an option. The session token for the authenticated user making the request is available in request.user.getSessionToken().
The ported Cloud function would now look like this:
// Parse Server Cloud Code
Parse.Cloud.define('getMessagesForUser', async (request) => {
// request.user replaces Parse.User.current()
const user = request.user;
// get session token from request
const token = user.getSessionToken();
const query = new Parse.Query('Messages');
query.equalTo('recipient', user);
// pass the session token to find()
const messages = await query.find({ sessionToken: token });
return messages;
});Parse.Cloud.useMasterKey() is not available in Parse Server Cloud Code. Instead, pass useMasterKey: true as an option to any operation that requires the use of the master key to bypass ACLs and/or CLPs.
Consider you want to write a Cloud function that returns the total count of messages sent by all of your users. Since the objects in our Message class are using ACLs to restrict read access, you will need to use the master key to get the total count:
Parse.Cloud.define('getTotalMessageCount', async (request) => {
// Parse.Cloud.useMasterKey() <-- no longer available!
const query = new Parse.Query('Messages');
const count = await query.count({ useMasterKey: true }); // count() will use the master key to bypass ACLs
return count;
});Parse Server also uses at least version 1.7.0 of the Parse SDK, which has some breaking changes from the previous versions. If your Parse.com Cloud Code uses a previous version of the SDK, you may need to update your cloud code. You can look up which version of the JavaScript SDK your Parse.com Cloud Code is using by running the following command inside your Cloud Code folder:
$ parse jssdk
Current JavaScript SDK version is 1.7.0
As with Parse Cloud Code, you can use Parse.Cloud.httpRequest to make network requests on Parse Server. It's worth noting that in Parse Server you can use any npm module, therefore you may also install the "request" module and use that directly instead.
Native Cloud Code modules are not available in Parse Server, so you will need to use a replacement:
-
App Links: Use the applinks-metatag module.
-
Buffer: This is included natively with Node. Remove any
require('buffer')calls. -
Mailgun: Use the official npm module: mailgun-js.
-
Mandrill: Use the official npm module, mandrill-api.
-
Moment: Use the official npm module, moment.
-
Parse Image: We recommend using another image manipulation library, like the imagemagick wrapper module. Alternatively, consider using a cloud-based image manipulation and management platform, such as Cloudinary.
-
SendGrid: Use the official npm module, sendgrid.
-
Stripe: Use the official npm module, stripe.
-
Twilio: Use the official npm module, twilio.
-
Underscore: Use the official npm module, underscore.
Parse has provided a separate Parse Dashboard project which can be used to manage all of your Parse Server applications.
Parse Config is available in Parse Server and can be configured from your Parse Dashboard.
You can now send push notifications using Parse Dashboard.
Parse Files in hosted Parse applications were limited to 10 MB. The default storage layer in Parse Server, GridStore, can handle files up to 16 MB. To store larger files, we suggest using Amazon's Simple Storage Service (S3).
iOS in-app purchase verification through Parse is not supported.
There is no background job functionality in Parse Server. If you have scheduled jobs, port them over to a self-hosted solution using a wide variety of open source job queue projects. A popular one is bull. Alternatively, if your jobs are simple, you could use a cron job.
Push notification support for the Parse IoT SDKs is provided through the Parse Push Notification Service (PPNS). PPNS is a push notification service for Android and IoT devices maintained by Parse. This service will be retired on January 28, 2017. This page documents the PPNS protocol for users that wish to create their own PPNS-compatible server for use with their Parse IoT devices.
Hosted Parse applications could disable a security setting in order to allow clients to send push notifications. Parse Server does not allow clients to send push notifications as the masterKey must be used. Use Cloud Code or the REST API to send push notifications.
Schema validation is built in. Retrieving the schema via API is available.
Parse Server requires the use of revocable sessions.
Parse Server only supports single app instances. There is ongoing work to make Parse Server multi-app aware. However, if you intend to run many different apps with different datastores, you currently would need to instantiate separate instances.
Facebook, Twitter, and Anonymous logins are supported out of the box. Support for additional platforms may be configured via the oauth configuration option.
Cloud Code Webhooks are not supported.
Verifying user email addresses and enabling password reset via email requires an email adapter. As part of the parse-server package we provide an adapter for sending email through Mailgun. To use it, sign up for Mailgun, and add this to your initialization code:
var server = ParseServer({
...otherOptions,
// Enable email verification
verifyUserEmails: true,
// if `verifyUserEmails` is `true` and
// if `emailVerifyTokenValidityDuration` is `undefined` then
// email verify token never expires
// else
// email verify token expires after `emailVerifyTokenValidityDuration`
//
// `emailVerifyTokenValidityDuration` defaults to `undefined`
//
// email verify token below expires in 2 hours (= 2 * 60 * 60 == 7200 seconds)
emailVerifyTokenValidityDuration: 2 * 60 * 60, // in seconds (2 hours = 7200 seconds)
// set preventLoginWithUnverifiedEmail to false to allow user to login without verifying their email
// set preventLoginWithUnverifiedEmail to true to prevent user from login if their email is not verified
preventLoginWithUnverifiedEmail: false, // defaults to false
// The public URL of your app.
// This will appear in the link that is used to verify email addresses and reset passwords.
// Set the mount path as it is in serverURL
publicServerURL: 'https://example.com/parse',
// Your apps name. This will appear in the subject and body of the emails that are sent.
appName: 'Parse App',
// The email adapter
emailAdapter: {
module: '@parse/simple-mailgun-adapter',
options: {
// The address that your emails come from
fromAddress: 'parse@example.com',
// Your domain from mailgun.com
domain: 'example.com',
// Your API key from mailgun.com
apiKey: 'key-mykey',
}
},
// account lockout policy setting (OPTIONAL) - defaults to undefined
// if the account lockout policy is set and there are more than `threshold` number of failed login attempts then the `login` api call returns error code `Parse.Error.OBJECT_NOT_FOUND` with error message `Your account is locked due to multiple failed login attempts. Please try again after <duration> minute(s)`. After `duration` minutes of no login attempts, the application will allow the user to try login again.
accountLockout: {
duration: 5, // duration policy setting determines the number of minutes that a locked-out account remains locked out before automatically becoming unlocked. Set it to a value greater than 0 and less than 100000.
threshold: 3, // threshold policy setting determines the number of failed sign-in attempts that will cause a user account to be locked. Set it to an integer value greater than 0 and less than 1000.
},
// optional settings to enforce password policies
passwordPolicy: {
// Two optional settings to enforce strong passwords. Either one or both can be specified.
// If both are specified, both checks must pass to accept the password
// 1. a RegExp object or a regex string representing the pattern to enforce
validatorPattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})/, // enforce password with at least 8 char with at least 1 lower case, 1 upper case and 1 digit
// 2. a callback function to be invoked to validate the password
validatorCallback: (password) => { return validatePassword(password) },
doNotAllowUsername: true, // optional setting to disallow username in passwords
maxPasswordAge: 90, // optional setting in days for password expiry. Login fails if user does not reset the password within this period after signup/last reset.
maxPasswordHistory: 5, // optional setting to prevent reuse of previous n passwords. Maximum value that can be specified is 20. Not specifying it or specifying 0 will not enforce history.
//optional setting to set a validity duration for password reset links (in seconds)
resetTokenValidityDuration: 24*60*60, // expire after 24 hours
}
});You can also use other email adapters contributed by the community such as: