'use strict';
const Managed = require('./Managed');
const EntityPartialUpdateBuilder = require('../partialupdate/EntityPartialUpdateBuilder');
/**
* @alias binding.Entity
* @extends binding.Managed
*/
class Entity extends Managed {
/**
* The default constructor, copy all given properties to this object
* @param {Object=} properties - The optional properties to copy
* @constructor
*/
}
Object.defineProperties(Entity.prototype, /** @lends binding.Entity.prototype */ {
/**
* The unique id of this object
*
* Sets the unique id of this object, if the id is not formatted as an valid id,
* it will be used as the key component of the id has the same affect as setting the key
*
* @type string
*/
id: {
get() {
return this._metadata.id;
},
set(value) {
if (this._metadata.id) {
throw new Error('The id can\'t be set twice: ' + value);
}
const val = value + '';
if (val.indexOf('/db/' + this._metadata.bucket + '/') === 0) {
this._metadata.id = value;
} else {
this.key = value;
}
},
enumerable: true,
},
/**
* The unique key part of the id
* When the key of the unique id is set an error will be thrown if an id is already set.
* @type string
*/
key: {
get() {
return this._metadata.key;
},
set(value) {
this._metadata.key = value;
},
},
/**
* The version of this object
* @type number
* @readonly
*/
version: {
get() {
return this._metadata.version;
},
enumerable: true,
},
/**
* The object read/write permissions
* @type Acl
* @readonly
*/
acl: {
get() {
return this._metadata.acl;
},
enumerable: true,
},
/**
* Date of the creation of the object
* @name createdAt
* @readonly
* @memberOf binding.Entity.prototype
* @type Date
*/
/**
* Last update date of the object
* @name updatedAt
* @readonly
* @memberOf binding.Entity.prototype
* @type Date
*/
/**
* Waits on the previously requested operation on this object completes
* @param {binding.Entity~doneCallback=} doneCallback The callback which will be invoked when the previously
* operations on this object is completed.
* @return {Promise<this>} A promise which completes successfully, when the previously requested
* operation completes
* @method
*/
ready: {
value: function ready(doneCallback) {
return this._metadata.ready(doneCallback);
},
},
/**
* Attach this object to the given db
* @param {EntityManager} db The db which will be used for future crud operations
* @return {void}
* @method
*/
attach: {
value: function attach(db) {
db.attach(this);
},
},
/**
* Saves the object. Inserts the object if it doesn't exists and updates the object if the object exist.
* @param {Object} [options] The save options
* @param {boolean} [options.force=false] Force the save operation, the version will not be validated.
* @param {number|boolean} [options.depth=0] The object depth which will be saved. Depth 0 save this object only,
* <code>true</code> saves the objects by reachability.
* @param {boolean} [options.refresh=false] Refresh the local object state from remote.
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
save: {
value: function save(options, doneCallback, failCallback) {
if (options instanceof Function) {
return this.save({}, options, doneCallback);
}
return this._metadata.db.save(this, options).then(doneCallback, failCallback);
},
},
/**
* Inserts a new object. Inserts the object if it doesn't exists and raise an error if the object already exist.
* @param {Object} [options] The insertion options
* @param {number|boolean} [options.depth=0] The object depth which will be inserted. Depth 0 insert this object only,
* <code>true</code> inserts objects by reachability.
* @param {boolean} [options.refresh=false] Refresh the local object state from remote.
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
insert: {
value: function insert(options, doneCallback, failCallback) {
if (options instanceof Function) {
return this.insert({}, options, doneCallback);
}
return this._metadata.db.insert(this, options).then(doneCallback, failCallback);
},
},
/**
* Updates an existing object
*
* Updates the object if it exists and raise an error if the object doesn't exist.
*
* @param {Object} [options] The update options
* @param {boolean} [options.force=false] Force the update operation,
* the version will not be validated, only existence will be checked.
* @param {number|boolean} [options.depth=0] The object depth which will be updated. Depth 0 updates this object only,
* <code>true</code> updates objects by reachability.
* @param {boolean} [options.refresh=false] Refresh the local object state from remote.
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
update: {
value: function update(options, doneCallback, failCallback) {
if (options instanceof Function) {
return this.update({}, options, doneCallback);
}
return this._metadata.db.update(this, options).then(doneCallback, failCallback);
},
},
/**
* Resolves the referenced object in the specified depth
*
* Only unresolved objects will be loaded unless the refresh option is specified.
*
* Removed objects will be marked as removed.
* @param {Object} [options] The load options
* @param {number|boolean} [options.depth=0] The object depth which will be loaded. Depth set to <code>true</code>
* loads objects by reachability.
* @param {boolean} [options.refresh=false] Refresh the local object state from remote.
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
load: {
value: function load(options, doneCallback, failCallback) {
if (options instanceof Function) {
return this.load({}, options, doneCallback);
}
const opt = options || {};
opt.local = true;
return this._metadata.db.load(this.id, null, opt).then(doneCallback, failCallback);
},
},
/**
* Deletes an existing object
*
* @param {Object} [options] The remove options
* @param {boolean} [options.force=false] Force the remove operation, the version will not be validated.
* @param {number|boolean} [options.depth=0] The object depth which will be removed. Depth 0 removes this object only,
* <code>true</code> removes objects by reachability.
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
delete: {
value: function deletee(options, doneCallback, failCallback) {
if (options instanceof Function) {
return this.delete({}, options, doneCallback);
}
return this._metadata.db.delete(this, options).then(doneCallback, failCallback);
},
},
/**
* Saves the object and repeats the operation if the object is out of date
*
* In each pass the callback will be called. Ths first parameter of the callback is the entity and the second one
* is a function to abort the process.
*
* @param {Function} cb Will be called in each pass
* @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
* @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
* @return {Promise<this>} A Promise that will be fulfilled when the asynchronous operation completes.
* @method
*/
optimisticSave: {
value: function optimisticSave(cb, doneCallback, failCallback) {
return this._metadata.db.optimisticSave(this, cb).then(doneCallback, failCallback);
},
},
attr: {
value: function attr() {
throw new Error('Attr is not yet implemented.');
},
},
/**
* Validates the entity by using the validation code of the entity type
*
* @return {util.ValidationResult} Contains the result of the Validation
* @method
*/
validate: {
value: function validate() {
return this._metadata.db.validate(this);
},
},
/**
* Starts a partial update on this entity
*
* @param {json=} operations
* @return {partialupdate.EntityPartialUpdateBuilder<this>}
* @method
*/
partialUpdate: {
value: function partialUpdate(operations) {
return new EntityPartialUpdateBuilder(this, operations);
},
},
/**
* Get all objects which refer to this object
*
* @param {Object} [options] Some options to pass
* @param {Array.<string>} [options.classes] An array of class names to filter for, null for no filter
* @return {Promise.<binding.Entity>} A promise resolving with an array of all referencing objects
* @method
*/
getReferencing: {
value: function getReferencing(options) {
const db = this._metadata.db;
const references = this._metadata.type.getReferencing(db, options);
// Query all possibly referencing objects
const allResults = Array.from(references).map((refAttr) => {
// Create query for given entity
const ref = refAttr[0];
const qb = db.createQueryBuilder(ref.typeConstructor);
// Add term for each attribute
const attrs = refAttr[1];
const terms = [];
attrs.forEach((attr) => {
terms.push(qb.equal(attr, this));
});
// If more than one term, put everything in a disjunction
const query = terms.length === 1 ? terms[0] : qb.or(terms);
return query.resultList();
});
return Promise.all(allResults).then(results => (
// Filter out all objects which did not match
results.filter(result => !!result.length)
)).then(results => (
// Flat the array of results
[].concat.apply([], results)
));
},
},
/**
* Converts the object to an JSON-Object
* @param {Object|boolean} [options=false] to json options by default excludes the metadata
* @param {boolean} [options.excludeMetadata=false] Excludes the metadata form the serialized json
* @param {number|boolean} [options.depth=0] Includes up to depth referenced objects into the serialized json
* @return {json} JSON-Object
* @method
*/
toJSON: {
value: function toJSON(options) {
// JSON.stringify calls toJSON with the parent key as the first argument.
// Therefore ignore all unknown option types.
let opt = options;
if (typeof opt === 'boolean') {
opt = {
excludeMetadata: opt,
};
}
if (typeof opt !== 'object') {
opt = {};
}
return this._metadata.getJson(opt);
},
},
});
module.exports = Entity;
/**
* The done callback is called, when the asynchronous operation completes successfully
* @callback binding.Entity~doneCallback
* @param {this} entity This entity
* @return {Promise<*>|*} A Promise, result or undefined
*/
/**
* The fail callback is called, when the asynchronous operation is rejected by an error
* @callback binding.Entity~failCallback
* @param {error.PersistentError} error The error which reject the operation
* @return {Promise<*>|*} A Promise, result or undefined
*/