You won't normally call this method directly. It is recommended that
* you use a subclass of Parse.Object instead, created by calling
* extend.
However, if you don't want to use a subclass, or aren't sure which * subclass is appropriate, you can use this form:
* var object = new Parse.Object("ClassName");
*
* That is basically equivalent to:
* var MyClass = Parse.Object.extend("ClassName");
* var object = new MyClass();
*
*
* @alias Parse.Object
*/
class ParseObject {
/**
* @param {string} className The class name for the object
* @param {object} attributes The initial set of data to store in the object.
* @param {object} options The options for this object instance.
*/
constructor(className /*: ?string | { className: string, [attr: string]: mixed }*/, attributes /*:: ?: { [attr: string]: mixed }*/, options /*:: ?: { ignoreValidation: boolean }*/) {
// Enable legacy initializers
if (typeof this.initialize === 'function') {
this.initialize.apply(this, arguments);
}
let toSet = null;
this._objCount = objectCount++;
if (typeof className === 'string') {
this.className = className;
if (attributes && typeof attributes === 'object') {
toSet = attributes;
}
} else if (className && typeof className === 'object') {
this.className = className.className;
toSet = {};
for (const attr in className) {
if (attr !== 'className') {
toSet[attr] = className[attr];
}
}
if (attributes && typeof attributes === 'object') {
options = attributes;
}
}
if (toSet && !this.set(toSet, options)) {
throw new Error("Can't create an invalid Parse Object");
}
}
/**
* The ID of this object, unique within its class.
*
* @property {string} id
*/
/*:: id: ?string;*/
/*:: _localId: ?string;*/
/*:: _objCount: number;*/
/*:: className: string;*/
/* Prototype getters / setters */
get attributes() /*: AttributeMap*/{
const stateController = _CoreManager.default.getObjectStateController();
return Object.freeze(stateController.estimateAttributes(this._getStateIdentifier()));
}
/**
* The first time this object was saved on the server.
*
* @property {Date} createdAt
* @returns {Date}
*/
get createdAt() /*: ?Date*/{
return this._getServerData().createdAt;
}
/**
* The last time this object was updated on the server.
*
* @property {Date} updatedAt
* @returns {Date}
*/
get updatedAt() /*: ?Date*/{
return this._getServerData().updatedAt;
}
/* Private methods */
/**
* Returns a local or server Id used uniquely identify this object
*
* @returns {string}
*/
_getId() /*: string*/{
if (typeof this.id === 'string') {
return this.id;
}
if (typeof this._localId === 'string') {
return this._localId;
}
const localId = 'local' + uuidv4();
this._localId = localId;
return localId;
}
/**
* Returns a unique identifier used to pull data from the State Controller.
*
* @returns {Parse.Object|object}
*/
_getStateIdentifier() /*: ParseObject | { id: string, className: string }*/{
if (singleInstance) {
let id = this.id;
if (!id) {
id = this._getId();
}
return {
id: id,
className: this.className
};
} else {
return this;
}
}
_getServerData() /*: AttributeMap*/{
const stateController = _CoreManager.default.getObjectStateController();
return stateController.getServerData(this._getStateIdentifier());
}
_clearServerData() {
const serverData = this._getServerData();
const unset = {};
for (const attr in serverData) {
unset[attr] = undefined;
}
const stateController = _CoreManager.default.getObjectStateController();
stateController.setServerData(this._getStateIdentifier(), unset);
}
_getPendingOps() /*: Arraytrue if the attribute contains a value that is not
* null or undefined.
*
* @param {string} attr The string name of the attribute.
* @returns {boolean}
*/
has(attr /*: string*/) /*: boolean*/{
const attributes = this.attributes;
if (attributes.hasOwnProperty(attr)) {
return attributes[attr] != null;
}
return false;
}
/**
* 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);
*
* @param {(string|object)} key The key to set.
* @param {(string|object)} value The value to give it.
* @param {object} options A set of options for the set.
* The only supported option is error.
* @returns {(ParseObject|boolean)} true if the set succeeded.
*/
set(key /*: mixed*/, value /*: mixed*/, options /*:: ?: mixed*/) /*: ParseObject | boolean*/{
let changes = {};
const newOps = {};
if (key && typeof key === 'object') {
changes = key;
options = value;
} else if (typeof key === 'string') {
changes[key] = value;
} else {
return this;
}
options = options || {};
let readonly = [];
if (typeof this.constructor.readOnlyAttributes === 'function') {
readonly = readonly.concat(this.constructor.readOnlyAttributes());
}
for (const k in changes) {
if (k === 'createdAt' || k === 'updatedAt') {
// This property is read-only, but for legacy reasons we silently
// ignore it
continue;
}
if (readonly.indexOf(k) > -1) {
throw new Error('Cannot modify readonly attribute: ' + k);
}
if (options.unset) {
newOps[k] = new _ParseOp.UnsetOp();
} else if (changes[k] instanceof _ParseOp.Op) {
newOps[k] = changes[k];
} else if (changes[k] && typeof changes[k] === 'object' && typeof changes[k].__op === 'string') {
newOps[k] = (0, _ParseOp.opFromJSON)(changes[k]);
} else if (k === 'objectId' || k === 'id') {
if (typeof changes[k] === 'string') {
this.id = changes[k];
}
} else if (k === 'ACL' && typeof changes[k] === 'object' && !(changes[k] instanceof _ParseACL.default)) {
newOps[k] = new _ParseOp.SetOp(new _ParseACL.default(changes[k]));
} else if (changes[k] instanceof _ParseRelation.default) {
const relation = new _ParseRelation.default(this, k);
relation.targetClassName = changes[k].targetClassName;
newOps[k] = new _ParseOp.SetOp(relation);
} else {
newOps[k] = new _ParseOp.SetOp(changes[k]);
}
}
const currentAttributes = this.attributes;
// Calculate new values
const newValues = {};
for (const attr in newOps) {
if (newOps[attr] instanceof _ParseOp.RelationOp) {
newValues[attr] = newOps[attr].applyTo(currentAttributes[attr], this, attr);
} else if (!(newOps[attr] instanceof _ParseOp.UnsetOp)) {
newValues[attr] = newOps[attr].applyTo(currentAttributes[attr]);
}
}
// Validate changes
if (!options.ignoreValidation) {
const validation = this.validate(newValues);
if (validation) {
if (typeof options.error === 'function') {
options.error(this, validation);
}
return false;
}
}
// Consolidate Ops
const pendingOps = this._getPendingOps();
const last = pendingOps.length - 1;
const stateController = _CoreManager.default.getObjectStateController();
for (const attr in newOps) {
const nextOp = newOps[attr].mergeWith(pendingOps[last][attr]);
stateController.setPendingOp(this._getStateIdentifier(), attr, nextOp);
}
return this;
}
/**
* Remove an attribute from the model. This is a noop if the attribute doesn't
* exist.
*
* @param {string} attr The string name of an attribute.
* @param options
* @returns {(ParseObject | boolean)}
*/
unset(attr /*: string*/, options /*:: ?: { [opt: string]: mixed }*/) /*: ParseObject | boolean*/{
options = options || {};
options.unset = true;
return this.set(attr, null, options);
}
/**
* 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.
*
* @param attr {String} The key.
* @param amount {Number} The amount to increment by (optional).
* @returns {(ParseObject|boolean)}
*/
increment(attr /*: string*/, amount /*:: ?: number*/) /*: ParseObject | boolean*/{
if (typeof amount === 'undefined') {
amount = 1;
}
if (typeof amount !== 'number') {
throw new Error('Cannot increment by a non-numeric amount.');
}
return this.set(attr, new _ParseOp.IncrementOp(amount));
}
/**
* 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.
*
* @param attr {String} The key.
* @param amount {Number} The amount to decrement by (optional).
* @returns {(ParseObject | boolean)}
*/
decrement(attr /*: string*/, amount /*:: ?: number*/) /*: ParseObject | boolean*/{
if (typeof amount === 'undefined') {
amount = 1;
}
if (typeof amount !== 'number') {
throw new Error('Cannot decrement by a non-numeric amount.');
}
return this.set(attr, new _ParseOp.IncrementOp(amount * -1));
}
/**
* Atomically add an object to the end of the array associated with a given
* key.
*
* @param attr {String} The key.
* @param item {} The item to add.
* @returns {(ParseObject | boolean)}
*/
add(attr /*: string*/, item /*: mixed*/) /*: ParseObject | boolean*/{
return this.set(attr, new _ParseOp.AddOp([item]));
}
/**
* Atomically add the objects to the end of the array associated with a given
* key.
*
* @param attr {String} The key.
* @param items {Object[]} The items to add.
* @returns {(ParseObject | boolean)}
*/
addAll(attr /*: string*/, items /*: ArrayParse.Object, in which case you can override this method
* to provide additional validation on set and
* save. Your implementation should return
*
* @param {object} attrs The current data to validate.
* @returns {Parse.Error|boolean} False if the data is valid. An error object otherwise.
* @see Parse.Object#set
*/
validate(attrs /*: AttributeMap*/) /*: ParseError | boolean*/{
if (attrs.hasOwnProperty('ACL') && !(attrs.ACL instanceof _ParseACL.default)) {
return new _ParseError.default(_ParseError.default.OTHER_CAUSE, 'ACL must be a Parse ACL.');
}
for (const key in attrs) {
if (!/^[A-Za-z][0-9A-Za-z_.]*$/.test(key)) {
return new _ParseError.default(_ParseError.default.INVALID_KEY_NAME);
}
}
return false;
}
/**
* Returns the ACL for this object.
*
* @returns {Parse.ACL} An instance of Parse.ACL.
* @see Parse.Object#get
*/
getACL() /*: ?ParseACL*/{
const acl = this.get('ACL');
if (acl instanceof _ParseACL.default) {
return acl;
}
return null;
}
/**
* Sets the ACL to be used for this object.
*
* @param {Parse.ACL} acl An instance of Parse.ACL.
* @param {object} options
* @returns {(ParseObject | boolean)} Whether the set passed validation.
* @see Parse.Object#set
*/
setACL(acl /*: ParseACL*/, options /*:: ?: mixed*/) /*: ParseObject | boolean*/{
return this.set('ACL', acl, options);
}
/**
* Clears any (or specific) changes to this object made since the last call to save()
*
* @param {string} [keys] - specify which fields to revert
*/
revert(...keys /*: Array* object.save();* or
* object.save(attrs);* or
* object.save(null, options);* or
* object.save(attrs, options);* or
* object.save(key, value);* or
* object.save(key, value, options);* * Example 1:
* gameTurn.save({
* player: "Jake Cutter",
* diceRoll: 2
* }).then(function(gameTurnAgain) {
* // The save was successful.
* }, function(error) {
* // The save failed. Error is an instance of Parse.Error.
* });
*
* Example 2:
* gameTurn.save("player", "Jake Cutter");
*
* @param {string | object | null} [arg1]
* Valid options are:* await object.pin(); ** * To retrieve object: *
query.fromLocalDatastore() or query.fromPin()
*
* @returns {Promise} A promise that is fulfilled when the pin completes.
*/
pin() /*: Promise* await object.unPin(); ** * @returns {Promise} A promise that is fulfilled when the unPin completes. */ unPin() /*: Promise
* const isPinned = await object.isPinned(); ** * @returns {Promise
* await object.pinWithName(name); ** * To retrieve object: *
query.fromLocalDatastore() or query.fromPinWithName(name)
*
* @param {string} name Name of Pin.
* @returns {Promise} A promise that is fulfilled when the pin completes.
*/
pinWithName(name /*: string*/) /*: Promise* await object.unPinWithName(name); ** * @param {string} name Name of Pin. * @returns {Promise} A promise that is fulfilled when the unPin completes. */ unPinWithName(name /*: string*/) /*: Promise
* await object.fetchFromLocalDatastore(); ** * You can create an unfetched pointer with
Parse.Object.createWithoutData()
* and then call fetchFromLocalDatastore() on it.
*
* @returns {Promise} A promise that is fulfilled when the fetch completes.
*/
async fetchFromLocalDatastore() /*: Promise
* Parse.Object.fetchAll([object1, object2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {object} options
* Valid options are:
* Parse.Object.fetchAllWithInclude([object1, object2, ...], [pointer1, pointer2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {string | Array
* Parse.Object.fetchAllIfNeededWithInclude([object1, object2, ...], [pointer1, pointer2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {string | Array
* Parse.Object.fetchAllIfNeeded([object1, ...])
* .then((list) => {
* // Objects were fetched and updated.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {object} options
* @static
* @returns {Parse.Object[]}
*/
static fetchAllIfNeeded(list /*: ArrayUnlike saveAll, if an error occurs while deleting an individual model, * this method will continue trying to delete the rest of the models if * possible, except in the case of a fatal error like a connection error. * *
In particular, the Parse.Error object returned in the case of error may * be one of two types: * *
* Parse.Object.destroyAll([object1, object2, ...])
* .then((list) => {
* // All the objects were deleted.
* }, (error) => {
* // An error occurred while deleting one or more of the objects.
* // If this is an aggregate error, then we can inspect each error
* // object individually to determine the reason why a particular
* // object was not deleted.
* if (error.code === Parse.Error.AGGREGATE_ERROR) {
* for (var i = 0; i < error.errors.length; i++) {
* console.log("Couldn't delete " + error.errors[i].object.id +
* "due to " + error.errors[i].message);
* }
* } else {
* console.log("Delete aborted because of " + error.message);
* }
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {object} options
* @static
* @returns {Promise} A promise that is fulfilled when the destroyAll
* completes.
*/
static destroyAll(list /*: Array
* Parse.Object.saveAll([object1, object2, ...])
* .then((list) => {
* // All the objects were saved.
* }, (error) => {
* // An error occurred while saving one of the objects.
* });
*
*
* @param {Array} list A list of Parse.Object.
* @param {object} options
* @static
* @returns {Parse.Object[]}
*/
static saveAll(list /*: ArrayA shortcut for:
* var Foo = Parse.Object.extend("Foo");
* var pointerToFoo = new Foo();
* pointerToFoo.id = "myObjectId";
*
*
* @param {string} id The ID of the object to create a reference to.
* @static
* @returns {Parse.Object} A Parse.Object reference.
*/
static createWithoutData(id /*: string*/) {
const obj = new this();
obj.id = id;
return obj;
}
/**
* Creates a new instance of a Parse Object from a JSON representation.
*
* @param {object} json The JSON map of the Object's data
* @param {boolean} override In single instance mode, all old server data
* is overwritten if this is set to true
* @param {boolean} dirty Whether the Parse.Object should set JSON keys to dirty
* @static
* @returns {Parse.Object} A Parse.Object reference
*/
static fromJSON(json /*: any*/, override /*:: ?: boolean*/, dirty /*:: ?: boolean*/) {
if (!json.className) {
throw new Error('Cannot create an object without a className');
}
const constructor = classMap[json.className];
const o = constructor ? new constructor(json.className) : new ParseObject(json.className);
const otherAttributes = {};
for (const attr in json) {
if (attr !== 'className' && attr !== '__type') {
otherAttributes[attr] = json[attr];
if (dirty) {
o.set(attr, json[attr]);
}
}
}
if (override) {
// id needs to be set before clearServerData can work
if (otherAttributes.objectId) {
o.id = otherAttributes.objectId;
}
let preserved = null;
if (typeof o._preserveFieldsOnFetch === 'function') {
preserved = o._preserveFieldsOnFetch();
}
o._clearServerData();
if (preserved) {
o._finishFetch(preserved);
}
}
o._finishFetch(otherAttributes);
if (json.objectId) {
o._setExisted(true);
}
return o;
}
/**
* Registers a subclass of Parse.Object with a specific class name.
* When objects of that class are retrieved from a query, they will be
* instantiated with this subclass.
* This is only necessary when using ES6 subclassing.
*
* @param {string} className The class name of the subclass
* @param {Function} constructor The subclass
*/
static registerSubclass(className /*: string*/, constructor /*: any*/) {
if (typeof className !== 'string') {
throw new TypeError('The first argument must be a valid class name.');
}
if (typeof constructor === 'undefined') {
throw new TypeError('You must supply a subclass constructor.');
}
if (typeof constructor !== 'function') {
throw new TypeError('You must register the subclass constructor. ' + 'Did you attempt to register an instance of the subclass?');
}
classMap[className] = constructor;
if (!constructor.className) {
constructor.className = className;
}
}
/**
* Unegisters a subclass of Parse.Object with a specific class name.
*
* @param {string} className The class name of the subclass
*/
static unregisterSubclass(className /*: string*/) {
if (typeof className !== 'string') {
throw new TypeError('The first argument must be a valid class name.');
}
delete classMap[className];
}
/**
* Creates a new subclass of Parse.Object for the given Parse class name.
*
* Every extension of a Parse class will inherit from the most recent * previous extension of that class. When a Parse.Object is automatically * created by parsing JSON, it will use the most recent extension of that * class.
* *You should call either:
* var MyClass = Parse.Object.extend("MyClass", {
* Instance methods,
* initialize: function(attrs, options) {
* this.someInstanceProperty = [],
* Other instance properties
* }
* }, {
* Class properties
* });
* or, for Backbone compatibility:
* var MyClass = Parse.Object.extend({
* className: "MyClass",
* Instance methods,
* initialize: function(attrs, options) {
* this.someInstanceProperty = [],
* Other instance properties
* }
* }, {
* Class properties
* });
*
* @param {string} className The name of the Parse class backing this model.
* @param {object} protoProps Instance properties to add to instances of the
* class returned from this method.
* @param {object} classProps Class properties to add the class returned from
* this method.
* @returns {Parse.Object} A new subclass of Parse.Object.
*/
static extend(className /*: any*/, protoProps /*: any*/, classProps /*: any*/) {
if (typeof className !== 'string') {
if (className && typeof className.className === 'string') {
return ParseObject.extend(className.className, className, protoProps);
} else {
throw new Error("Parse.Object.extend's first argument should be the className.");
}
}
let adjustedClassName = className;
if (adjustedClassName === 'User' && _CoreManager.default.get('PERFORM_USER_REWRITE')) {
adjustedClassName = '_User';
}
let parentProto = ParseObject.prototype;
if (this.hasOwnProperty('__super__') && this.__super__) {
parentProto = this.prototype;
}
let ParseObjectSubclass = function (attributes, options) {
this.className = adjustedClassName;
this._objCount = objectCount++;
// Enable legacy initializers
if (typeof this.initialize === 'function') {
this.initialize.apply(this, arguments);
}
if (this._initializers) {
for (const initializer of this._initializers) {
initializer.apply(this, arguments);
}
}
if (attributes && typeof attributes === 'object') {
if (!this.set(attributes || {}, options)) {
throw new Error("Can't create an invalid Parse Object");
}
}
};
if (classMap[adjustedClassName]) {
ParseObjectSubclass = classMap[adjustedClassName];
} else {
ParseObjectSubclass.extend = function (name, protoProps, classProps) {
if (typeof name === 'string') {
return ParseObject.extend.call(ParseObjectSubclass, name, protoProps, classProps);
}
return ParseObject.extend.call(ParseObjectSubclass, adjustedClassName, name, protoProps);
};
ParseObjectSubclass.createWithoutData = ParseObject.createWithoutData;
ParseObjectSubclass.className = adjustedClassName;
ParseObjectSubclass.__super__ = parentProto;
ParseObjectSubclass.prototype = Object.create(parentProto, {
constructor: {
value: ParseObjectSubclass,
enumerable: false,
writable: true,
configurable: true
}
});
}
if (protoProps) {
for (const prop in protoProps) {
if (prop === 'initialize') {
Object.defineProperty(ParseObjectSubclass.prototype, '_initializers', {
value: [...(ParseObjectSubclass.prototype._initializers || []), protoProps[prop]],
enumerable: false,
writable: true,
configurable: true
});
continue;
}
if (prop !== 'className') {
Object.defineProperty(ParseObjectSubclass.prototype, prop, {
value: protoProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
}
}
if (classProps) {
for (const prop in classProps) {
if (prop !== 'className') {
Object.defineProperty(ParseObjectSubclass, prop, {
value: classProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
}
}
classMap[adjustedClassName] = ParseObjectSubclass;
return ParseObjectSubclass;
}
/**
* Enable single instance objects, where any local objects with the same Id
* share the same attributes, and stay synchronized with each other.
* This is disabled by default in server environments, since it can lead to
* security issues.
*
* @static
*/
static enableSingleInstance() {
singleInstance = true;
_CoreManager.default.setObjectStateController(SingleInstanceStateController);
}
/**
* Disable single instance objects, where any local objects with the same Id
* share the same attributes, and stay synchronized with each other.
* When disabled, you can have two instances of the same object in memory
* without them sharing attributes.
*
* @static
*/
static disableSingleInstance() {
singleInstance = false;
_CoreManager.default.setObjectStateController(UniqueInstanceStateController);
}
/**
* Asynchronously stores the objects and every object they point 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 Parse.Object.pinAll([...]); ** * To retrieve object: *
query.fromLocalDatastore() or query.fromPin()
*
* @param {Array} objects A list of Parse.Object.
* @returns {Promise} A promise that is fulfilled when the pin completes.
* @static
*/
static pinAll(objects /*: Array* await Parse.Object.pinAllWithName(name, [obj1, obj2, ...]); ** * To retrieve object: *
query.fromLocalDatastore() or query.fromPinWithName(name)
*
* @param {string} name Name of Pin.
* @param {Array} objects A list of Parse.Object.
* @returns {Promise} A promise that is fulfilled when the pin completes.
* @static
*/
static pinAllWithName(name /*: string*/, objects /*: Array* await Parse.Object.unPinAll([...]); ** * @param {Array} objects A list of
Parse.Object.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAll(objects /*: Array* await Parse.Object.unPinAllWithName(name, [obj1, obj2, ...]); ** * @param {string} name Name of Pin. * @param {Array} objects A list of
Parse.Object.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAllWithName(name /*: string*/, objects /*: Array* await Parse.Object.unPinAllObjects(); ** * @returns {Promise} A promise that is fulfilled when the unPin completes. * @static */ static unPinAllObjects() /*: Promise
* await Parse.Object.unPinAllObjectsWithName(name); ** * @param {string} name Name of Pin. * @returns {Promise} A promise that is fulfilled when the unPin completes. * @static */ static unPinAllObjectsWithName(name /*: string*/) /*: Promise