User

Removes null values from authData (which exist temporarily for unlinking)

Returns a local or server Id used uniquely identify this object

Returns a unique identifier used to pull data from the State Controller.

Checks whether a user is linked to a service.

Deauthenticates a single provider (e.g. removing access tokens from the Facebook SDK).

Deauthenticates all providers.

Class instance method used to maintain specific keys when a fetch occurs. Used to ensure that the session token is not lost.

Synchronizes authData for all providers.

Synchronizes auth data for a provider (e.g. puts the access token in the right place to be used by the Facebook SDK).

Unlinks a user from a service.

Request a revocable session token to replace the older style of token.

Atomically add an object to the end of the array associated with a given key.

Atomically add the objects to the end of the array associated with a given key.

Atomically add the objects to the array associated with a given key, only if it is not already present in the array. The position of the insert is not guaranteed.

Atomically add an object to the array associated with a given key, only if it is not already present in the array. The position of the insert is not guaranteed.

Checks whether this user is the current user and has been authenticated.

Clears all attributes on a model

Creates a new model with identical attributes to this one.

Atomically decrements the value of the given attribute the next time the object is saved. If no amount is specified, 1 is used by default.

Wrap the default destroy behavior with functionality that logs out the current user when it is destroyed

Deletes this object from the server at some unspecified time in the future, even if Parse is currently inaccessible.

Use this when you may not have a solid network connection, and don't need to know when the delete completes. If there is some problem with the object such that it can't be deleted, the request will be silently discarded.

Delete instructions made with this method will be stored locally in an on-disk cache until they can be transmitted to Parse. They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection is available. Delete requests will persist even after the app is closed, in which case they will be sent the next time the app is opened.

Returns true if this object has been modified since its last save/refresh. If an attribute is specified, it returns true only if that particular attribute has been modified since the last save/refresh.

Returns an array of keys that have been modified since last save/refresh

Determines whether this ParseObject is equal to another ParseObject

Gets the HTML-escaped value of an attribute.

Returns true if this object was created by the Parse server when the object might have already been there (e.g. in the case of a Facebook login)

Returns true if this object exists on the Server

Wrap the default fetch behavior with functionality to save to local storage if this is current user.

Asynchronously loads data from the local datastore into this object.

await object.fetchFromLocalDatastore();

You can create an unfetched pointer with Parse.Object.createWithoutData() and then call fetchFromLocalDatastore() on it.

Wrap the default fetchWithInclude behavior with functionality to save to local storage if this is current user.

Gets the value of an attribute.

Returns the ACL for this object.

Returns get("email").

Returns the session token for this user, if the user has been logged in, or if it is the result of a query with the master key. Otherwise, returns undefined.

Returns get("username").

Returns true if the attribute contains a value that is not null or undefined.

Atomically increments the value of the given attribute the next time the object is saved. If no amount is specified, 1 is used by default.

Returns true if current would return this user.

Returns true if current would return this user.

Returns true if the object has been fetched.

Returns true if this object has never been saved to Parse.

Asynchronously returns if the object is pinned

const isPinned = await object.isPinned();

Checks if the model is currently in a valid state.

Parse allows you to link your users with 3rd party authentication, enabling your users to sign up or log into your application using their existing identities. Since 2.9.0

Logs in a Parse.User. On success, this saves the session to disk, so you can retrieve the currently logged in user using current.

A username and password must be set before calling logIn.

Creates a new instance of this object. Not to be confused with clone()

Returns an instance of a subclass of Parse.Op describing what kind of modification has been performed on this field since the last time it was saved. For example, after calling object.increment("x"), calling object.op("x") would return an instance of Parse.Op.Increment.

Asynchronously stores the object and every object it points to in the local datastore, recursively, using a default pin name: _default.

If those other objects have not been fetched from Parse, they will not be stored. However, if they have changed data, all the changes will be retained.

await object.pin();

To retrieve object: query.fromLocalDatastore() or query.fromPin()

Asynchronously stores the objects and every object they point to in the local datastore, recursively.

If those other objects have not been fetched from Parse, they will not be stored. However, if they have changed data, all the changes will be retained.

await object.pinWithName(name);

To retrieve object: query.fromLocalDatastore() or query.fromPinWithName(name)

Gets a relation on the given class for the attribute.

Atomically remove all instances of an object from the array associated with a given key.

Atomically remove all instances of the objects from the array associated with a given key.

Clears any (or specific) changes to this object made since the last call to save()

Wrap the default save behavior with functionality to save to local storage if this is current user.

Saves this object to the server at some unspecified time in the future, even if Parse is currently inaccessible.

Use this when you may not have a solid network connection, and don't need to know when the save completes. If there is some problem with the object such that it can't be saved, it will be silently discarded.

Objects saved with this method will be stored locally in an on-disk cache until they can be delivered to Parse. They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection is available. Objects saved this way will persist even after the app is closed, in which case they will be sent the next time the app is opened.

Sets a hash of model attributes on the object.

You can call it with an object containing keys and values, with one key and value, or dot notation. For example:

  gameTurn.set({
    player: player1,
    diceRoll: 2
  }, {
    error: function(gameTurnAgain, error) {
      // The set failed validation.
    }
  });
game.set("currentPlayer", player2, {
error: function(gameTurnAgain, error) {
// The set failed validation.
}
});
game.set("finished", true);

game.set("player.score", 10);

Sets the ACL to be used for this object.

Calls set("email", email) and returns the result.

Calls set("password", password, options) and returns the result.

Calls set("username", username, options) and returns the result.

Signs up a new user. You should call this instead of save for new Parse.Users. This will create a new Parse.User on the server, and also persist the session on disk so that you can access the user using current.

A username and password must be set before calling signUp.

Returns a JSON version of the object suitable for saving to Parse.

Gets a Pointer referencing this Object.

Gets a Pointer referencing this Object.

Asynchronously removes the object and every object it points to in the local datastore, recursively, using a default pin name: _default.

await object.unPin();

Asynchronously removes the object and every object it points to in the local datastore, recursively.

await object.unPinWithName(name);

Remove an attribute from the model. This is a noop if the attribute doesn't exist.

You should not call this function directly unless you subclass Parse.Object, in which case you can override this method to provide additional validation on set and save. Your implementation should return

Verify whether a given password is the password of the current user.

When registering users with linkWith a basic auth provider is automatically created for you.

For advanced authentication, you can register an Auth provider to implement custom authentication, deauthentication.

Allow someone to define a custom User class without className being rewritten to _User. The default behavior is to rewrite User to _User for legacy reasons. This allows developers to override that behavior.

Logs in a user with a session token. On success, this saves the session to disk, so you can retrieve the currently logged in user using current.

Retrieves the currently logged in ParseUser with a valid session, either from memory or localStorage, if necessary.

Retrieves the currently logged in ParseUser from asynchronous Storage.

Disables the use of become or the current user in any environment. These features are disabled on servers by default, since they depend on global objects that are not memory-safe for most servers.

Allows a legacy application to start using revocable sessions. If the current session token is not revocable, a request will be made for a new, revocable session. It is not necessary to call this method from cloud code unless you are handling user signup or login from the server side. In a cloud code call, this function will not attempt to upgrade the current token.

Enables the use of become or the current user in a server environment. These features are disabled by default, since they depend on global objects that are not memory-safe for most servers.

Adds functionality to the existing Parse.User class.

Logs in a user with a session token. On success, this saves the session to disk, so you can retrieve the currently logged in user using current. If there is no session token the user will not logged in.

Logs in a user with a username (or email) and password. On success, this saves the session to disk, so you can retrieve the currently logged in user using current.

Static version of linkWith

Logs in a user with a username (or email) and password, and authData. On success, this saves the session to disk, so you can retrieve the currently logged in user using current.

Logs out the currently logged in user session. This will remove the session from disk, log out of linked services, and future calls to current will return null.

Logs in a user with an objectId. On success, this saves the session to disk, so you can retrieve the currently logged in user using current.

Retrieves a user with a session token.

Request an email verification.

Requests a password reset email to be sent to the specified email address associated with the user account. This email allows the user to securely reset their password on the Parse site.

Signs up a new user with a username (or email) and password. This will create a new Parse.User on the server, and also persist the session in localStorage so that you can access the user using #current.

Verify whether a given password is the password of the current user.