Adds decrement() to ParseObject

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "parse",
+  "name": "@leapllc/parse",
   "version": "2.11.0",
   "description": "The Parse JavaScript SDK",
   "homepage": "https://parseplatform.org/",
@@ -11,7 +11,7 @@
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
-    "url": "https://github.com/parse-community/Parse-SDK-JS"
+    "url": "https://github.com/stevestencil/Parse-SDK-JS.git"
   },
   "bugs": "https://github.com/parse-community/Parse-SDK-JS/issues",
   "files": [

src/CloudCode.js

@@ -101,6 +101,71 @@
  * @param {Function} func The function to run before a save. This function should take two parameters a {@link Parse.Cloud.TriggerRequest} and a {@link Parse.Cloud.BeforeSaveResponse}.
  */
 
+/**
+ *
+ * Registers an before save file function. A new Parse.File can be returned to override the file that gets saved.
+ * If you want to replace the rquesting Parse.File with a Parse.File that is already saved, simply return the already saved Parse.File.
+ * You can also add metadata to the file that will be stored via whatever file storage solution you're using.
+ *
+ * **Available in Cloud Code only.**
+ *
+ * Example: Adding metadata and tags
+ * ```
+ * Parse.Cloud.beforeSaveFile(({ file, user }) => {
+ *   file.addMetadata('foo', 'bar');
+ *   file.addTag('createdBy', user.id);
+ * });
+ *
+ * ```
+ *
+ * Example: replacing file with an already saved file
+ *
+ * ```
+ * Parse.Cloud.beforeSaveFile(({ file, user }) => {
+ *   return user.get('avatar');
+ * });
+ *
+ * ```
+ *
+ * Example: replacing file with a different file
+ *
+ * ```
+ * Parse.Cloud.beforeSaveFile(({ file, user }) => {
+ *   const metadata = { foo: 'bar' };
+ *   const tags = { createdBy: user.id };
+ *   const newFile = new Parse.File(file.name(), <some other file data>, 'text/plain', metadata, tags);
+ *   return newFile;
+ * });
+ *
+ * ```
+ *
+ * @method beforeSaveFile
+ * @name Parse.Cloud.beforeSaveFile
+ * @param {Function} func The function to run before a file saves. This function should take one parameter, a {@link Parse.Cloud.FileTriggerRequest}.
+ */
+
+/**
+ *
+ * Registers an after save file function.
+ *
+ * **Available in Cloud Code only.**
+ *
+ * Example: creating a new object that references this file in a separate collection
+ * ```
+ * Parse.Cloud.afterSaveFile(async ({ file, user }) => {
+ *   const fileObject = new Parse.Object('FileObject');
+ *   fileObject.set('metadata', file.metadata());
+ *   fileObject.set('tags', file.tags());
+ *   fileObject.set('name', file.name());
+ *   fileObject.set('createdBy', user);
+ *   await fileObject.save({ sessionToken: user.getSessionToken() });
+ * });
+ *
+ * @method afterSaveFile
+ * @name Parse.Cloud.afterSaveFile
+ * @param {Function} func The function to run after a file saves. This function should take one parameter, a {@link Parse.Cloud.FileTriggerRequest}.
+ */
+
 /**
  * Makes an HTTP Request.
  *
@@ -152,6 +217,18 @@
  * @property {Parse.Object} original If set, the object, as currently stored.
  */
 
+/**
+ * @typedef Parse.Cloud.FileTriggerRequest
+ * @property {String} installationId If set, the installationId triggering the request.
+ * @property {Boolean} master If true, means the master key was used.
+ * @property {Parse.User} user If set, the user that made the request.
+ * @property {Parse.File} file The file triggering the hook.
+ * @property {String} ip The IP address of the client making the request.
+ * @property {Object} headers The original HTTP headers for the request.
+ * @property {String} triggerName The name of the trigger (`beforeSaveFile`, `afterSaveFile`, ...)
+ * @property {Object} log The current logger inside Parse Server.
+ */
+
 /**
  * @typedef Parse.Cloud.FunctionRequest
  * @property {String} installationId If set, the installationId triggering the request.

src/ParseFile.js

@@ -71,6 +71,8 @@ class ParseFile {
   _previousSave: ?Promise<ParseFile>;
   _data: ?string;
   _requestTask: ?any;
+  _metadata: ?Object;
+  _tags: ?Object;
 
   /**
    * @param name {String} The file's name. This will be prefixed by a unique
@@ -99,11 +101,15 @@ class ParseFile {
    * @param type {String} Optional Content-Type header to use for the file. If
    *     this is omitted, the content type will be inferred from the name's
    *     extension.
+   * @param metadata {Object} Optional key value pairs to be stored with file object
+   * @param tags {Object} Optional key value pairs to be stored with file object
    */
-  constructor(name: string, data?: FileData, type?: string) {
+  constructor(name: string, data?: FileData, type?: string, metadata?: Object, tags?: Object) {
     const specifiedType = type || '';
 
     this._name = name;
+    this._metadata = metadata || {};
+    this._tags = tags || {};
 
     if (data !== undefined) {
       if (Array.isArray(data)) {
@@ -174,6 +180,7 @@ class ParseFile {
     this._data = result.base64;
     return this._data;
   }
+
   /**
    * Gets the name of the file. Before save is called, this is the filename
    * given by the user. After save is called, that name gets prefixed with a
@@ -202,6 +209,22 @@ class ParseFile {
     }
   }
 
+  /**
+   * Gets the metadata of the file.
+   * @return {Object}
+   */
+  metadata(): Object {
+    return this._metadata;
+  }
+
+  /**
+   * Gets the tags of the file.
+   * @return {Object}
+   */
+  tags(): Object {
+    return this._tags;
+  }
+
   /**
    * Saves the file to the Parse cloud.
    * @param {Object} options
@@ -217,6 +240,8 @@ class ParseFile {
   save(options?: FullOptions) {
     options = options || {};
     options.requestTask = (task) => this._requestTask = task;
+    options.metadata = this._metadata;
+    options.tags = this._tags;
 
     const controller = CoreManager.getFileController();
     if (!this._previousSave) {
@@ -310,6 +335,52 @@ class ParseFile {
     );
   }
 
+  /**
+   * Sets metadata to be saved with file object. Overwrites existing metadata
+   * @param {Object} metadata Key value pairs to be stored with file object
+   */
+  setMetadata(metadata: any) {
+    if (metadata && typeof metadata === 'object') {
+      Object.keys(metadata).forEach((key) => {
+        this.addMetadata(key, metadata[key]);
+      });
+    }
+  }
+
+  /**
+   * Sets metadata to be saved with file object. Adds to existing metadata
+   * @param {String} key
+   * @param {Mixed} value
+   */
+  addMetadata(key: string, value: any) {
+    if (typeof key === 'string') {
+      this._metadata[key] = value;
+    }
+  }
+
+  /**
+   * Sets tags to be saved with file object. Overwrites existing tags
+   * @param {Object} tags Key value pairs to be stored with file object
+   */
+  setTags(tags: any) {
+    if (tags && typeof tags === 'object') {
+      Object.keys(tags).forEach((key) => {
+        this.addTag(key, tags[key]);
+      });
+    }
+  }
+
+  /**
+   * Sets tags to be saved with file object. Adds to existing tags
+   * @param {String} key
+   * @param {Mixed} value
+   */
+  addTag(key: string, value: string) {
+    if (typeof key === 'string') {
+      this._tags[key] = value;
+    }
+  }
+
   static fromJSON(obj): ParseFile {
     if (obj.__type !== 'File') {
       throw new TypeError('JSON object does not represent a ParseFile');

src/ParseObject.js

@@ -764,6 +764,24 @@ class ParseObject {
     return this.set(attr, new 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).
+   * @return {(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 IncrementOp(amount * -1));
+  }
+
   /**
    * Atomically add an object to the end of the array associated with a given
    * key.

src/__tests__/ParseFile-test.js

@@ -259,6 +259,78 @@ describe('ParseFile', () => {
     file.cancel();
     expect(mockRequestTask.abort).toHaveBeenCalledTimes(1);
   });
+
+  it('should save file with metadata and tag options', async () => {
+    const fileController = {
+      saveFile: jest.fn().mockResolvedValue({}),
+      saveBase64: () => {},
+      download: () => {},
+    };
+    CoreManager.setFileController(fileController);
+    const file = new ParseFile('donald_duck.txt', new File(['Parse'], 'donald_duck.txt'));
+    file.addMetadata('foo', 'bar');
+    file.addTag('bar', 'foo');
+    await file.save();
+    expect(fileController.saveFile).toHaveBeenCalledWith(
+      'donald_duck.txt',
+      {
+        file: expect.any(File),
+        format: 'file',
+        type: ''
+      },
+      {
+        metadata: { foo: 'bar' },
+        tags: { bar: 'foo' },
+        requestTask: expect.any(Function),
+      },
+    );
+  });
+
+  it('should create new ParseFile with metadata and tags', () => {
+    const metadata = { foo: 'bar' };
+    const tags = { bar: 'foo' };
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120], '', metadata, tags);
+    expect(file._source.base64).toBe('ParseA==');
+    expect(file._source.type).toBe('');
+    expect(file.metadata()).toBe(metadata);
+    expect(file.tags()).toBe(tags);
+  });
+
+  it('should set metadata', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.setMetadata({ foo: 'bar' });
+    expect(file.metadata()).toEqual({ foo: 'bar' });
+  });
+
+  it('should set metadata key', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.addMetadata('foo', 'bar');
+    expect(file.metadata()).toEqual({ foo: 'bar' });
+  });
+
+  it('should not set metadata if key is not a string', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.addMetadata(10, '');
+    expect(file.metadata()).toEqual({});
+  });
+
+  it('should set tags', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.setTags({ foo: 'bar' });
+    expect(file.tags()).toEqual({ foo: 'bar' });
+  });
+
+  it('should set tag key', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.addTag('foo', 'bar');
+    expect(file.tags()).toEqual({ foo: 'bar' });
+  });
+
+  it('should not set tag if key is not a string', () => {
+    const file = new ParseFile('parse.txt', [61, 170, 236, 120]);
+    file.addTag(10, 'bar');
+    expect(file.tags()).toEqual({});
+  });
 });
 
 describe('FileController', () => {

src/__tests__/ParseObject-test.js

@@ -491,6 +491,50 @@ describe('ParseObject', () => {
     expect(o2.attributes).toEqual({ age: 41 });
   });
 
+
+  it('can decrement a field', () => {
+    const o = new ParseObject('Person');
+    o.decrement('age');
+    expect(o.attributes).toEqual({ age: -1 });
+    expect(o.op('age') instanceof IncrementOp).toBe(true);
+    expect(o.dirtyKeys()).toEqual(['age']);
+    expect(o._getSaveJSON()).toEqual({
+      age: { __op: 'Increment', amount: -1 }
+    });
+
+    o.decrement('age', 4);
+    expect(o.attributes).toEqual({ age: -5 });
+    expect(o._getSaveJSON()).toEqual({
+      age: { __op: 'Increment', amount: -5 }
+    });
+
+    expect(o.decrement.bind(o, 'age', 'four')).toThrow(
+      'Cannot decrement by a non-numeric amount.'
+    );
+    expect(o.decrement.bind(o, 'age', null)).toThrow(
+      'Cannot decrement by a non-numeric amount.'
+    );
+    expect(o.decrement.bind(o, 'age', { amount: 4 })).toThrow(
+      'Cannot decrement by a non-numeric amount.'
+    );
+
+    o.set('age', 30);
+    o.decrement('age');
+    expect(o.attributes).toEqual({ age: 29 });
+    expect(o._getSaveJSON()).toEqual({
+      age: 29
+    });
+
+    const o2 = new ParseObject('Person');
+    o2._finishFetch({
+      objectId: 'ABC123',
+      age: 40
+    });
+    expect(o2.attributes).toEqual({ age: 40 });
+    o2.decrement('age');
+    expect(o2.attributes).toEqual({ age: 39 });
+  });
+
   it('can set nested field', () => {
     const o = new ParseObject('Person');
     o._finishFetch({