Merge pull request #14 from owsas/feature/object-config

Feature/object config

Author: jcguarinpenaranda

README.md

@@ -35,6 +35,54 @@ A working example can be found here: https://github.com/owsas/parse-cloud-class-
 * Parse >=2.0
 * Parse >=3.0
 
+## New: Configuration with objects
+Starting april 2019 (v1.1.0), it's possible to create classes with configuration objects
+
+Example:
+```js
+const ParseCloudClass = require('parse-server-addon-cloud-class').ParseCloudClass;
+
+// Create a new configuration object to define the class behaviour.
+// All attributes are optional
+const gamePoint = {
+  requiredKeys: ['points'], // all objects saved must have the points attribute
+  defaultValues: { points: 20 }, // by default, all new objects will have 20 points (if it was not set at the time of creation) 
+  minimumValues: { points: 10 }, // minimum 10 points
+  maximumValues: { points: 1000 }, // maximum 1000 points
+  immutableKeys: ['points'], // once set, the points can't be changed (only master can do that)
+  beforeFind: function(req) {
+    // Do something here
+    return req.query;
+  },
+  processBeforeSave: async function(req) {
+    // Do something here
+    return req.object;
+  },
+  afterSave: async function(req) {
+    // Do something here
+    return req.object;
+  },
+  processBeforeDelete: async function(req) {
+    // Do something here
+    return req.object;
+  },
+  afterDelete: async function(req) {
+    // Do something here
+    return req.object;
+  }
+}
+
+// Create an instance
+const gamePointClass = ParseCloudClass.fromObject(gamePoint);
+
+// Configure the class in the main.js cloud file
+ParseCloudClass.configureClass(Parse, 'GamePoint', gamePointClass);
+```
+
+As you see, instead of defining `beforeSave`, we use `processBeforeSave`. This is because ParseCloudClass uses the `beforeSave` function to wrap up some extra logic that we may not want to rewrite each time. In the same fashion, we use `processBeforeDelete`.
+
+With this new functionality, the `this` keyword inside the `beforeFind`, `processBeforeSave`, `afterSave`, `processBeforeDelete` and `beforeDelete` functions refers to the instance itself, which means you can access for example `this.requiredKeys`, etc.
+
 ## Basic Usage
 ```js
 /*
@@ -267,6 +315,24 @@ class Addon1 extends ParseCloudClass {
 }
 ```
 
+Now you can also create addons using the new configuration objects, for example:
+
+```js
+const dbAddon = {
+  afterSave: async function(req) {
+    // replicate data to the other db
+    return req.object;
+  },
+  afterDelete: async function(req) {
+    // replicate data to the other db
+    return req.object;
+  }
+}
+
+const addonInstance = ParseCloudClass.fromObject(dbAddon);
+```
+
+
 ## Addons
 
 * Algolia Search: https://github.com/owsas/parse-server-addon-cloud-algolia 

src/ParseCloudClass.ts

@@ -29,6 +29,41 @@ export interface IProcessResponse {
   error: ((e: any) => void);
 }
 
+export interface IConstructorParams {
+  requiredKeys?: string[];
+  defaultValues?: {[key: string]: any};
+  minimumValues?: {[key: string]: number};
+  maximumValues?: {[key: string]: number};
+  immutableKeys?: string[];
+}
+
+/**
+ * Interface that describes a configuration object
+ */
+export interface ICloudClassObject extends IConstructorParams {
+  addons?: ParseCloudClass[];
+
+  beforeFind?: (
+    req: Parse.Cloud.BeforeFindRequest,
+  ) => Parse.Query;
+
+  processBeforeSave?: (
+    req: Parse.Cloud.BeforeSaveRequest,
+  ) => Promise<Parse.Object>;
+
+  afterSave?: (
+    req: Parse.Cloud.AfterSaveRequest,
+  ) => Promise<Parse.Object>;
+
+  processBeforeDelete?: (
+    req: Parse.Cloud.BeforeSaveRequest,
+  ) => Promise<Parse.Object>;
+
+  afterDelete?: (
+    req: Parse.Cloud.AfterSaveRequest,
+  ) => Promise<Parse.Object>;
+}
+
 /**
  * Defines the methods every ParseCloudClass should have
  */
@@ -79,13 +114,7 @@ export default class ParseCloudClass implements IParseCloudClass {
   addons: ParseCloudClass [] = [];
   immutableKeys: string[] = [];
 
-  constructor (params?: {
-    requiredKeys?: string[],
-    defaultValues?: {[key: string]: any},
-    minimumValues?: {[key: string]: number},
-    maximumValues?: {[key: string]: number},
-    immutableKeys?: string[],
-  }) {
+  constructor (params?: IConstructorParams) {
     if (params) {
       if (params.requiredKeys) {
         this.requiredKeys = params.requiredKeys;
@@ -116,6 +145,84 @@ export default class ParseCloudClass implements IParseCloudClass {
     this.useAddon = this.useAddon.bind(this);
   }
 
+  /**
+   * Get a class configuration based
+   * on a JSON object
+   * @param object
+   */
+  static fromObject (object: ICloudClassObject): ParseCloudClass {
+    // Create a class that extends the ParseCloudClass and adds behaviours
+    // set in the object
+    class ExtendedCloudClass extends ParseCloudClass {
+      beforeFind(req: Parse.Cloud.BeforeFindRequest): Parse.Query {
+        let query = super.beforeFind(req);
+
+        if (object.beforeFind) {
+          query = object.beforeFind.bind(this)(req);
+        }
+
+        return query;
+      }
+
+      async processBeforeSave (
+        req: Parse.Cloud.BeforeSaveRequest | IProcessRequest,
+      ): Promise<Parse.Object> {
+        let obj = await super.processBeforeSave(req);
+
+        if (object.processBeforeSave) {
+          obj =  await object.processBeforeSave.bind(this)(req);
+        }
+
+        return obj;
+      }
+
+      async afterSave(req: Parse.Cloud.AfterSaveRequest): Promise<Parse.Object> {
+        let obj = await super.afterSave(req);
+
+        if (object.afterSave) {
+          obj = await object.afterSave.bind(this)(req);
+        }
+
+        return obj;
+      }
+
+      async processBeforeDelete (
+        req: Parse.Cloud.BeforeDeleteRequest | IProcessRequest,
+      ): Promise<Parse.Object> {
+        let obj = await super.processBeforeDelete(req);
+
+        if (object.processBeforeDelete) {
+          obj =  await object.processBeforeDelete.bind(this)(req);
+        }
+
+        return obj;
+      }
+
+      async afterDelete(
+        req: Parse.Cloud.AfterDeleteRequest,
+      ): Promise<Parse.Object> {
+        let obj = await super.afterDelete(req);
+
+        if (object.afterDelete) {
+          obj = await object.afterDelete.bind(this)(req);
+        }
+
+        return obj;
+      }
+    }
+
+    const cloudClass = new ExtendedCloudClass(object);
+
+    // Attach the addons
+    if (object.addons && object.addons.length) {
+      object.addons.forEach((addon) => {
+        cloudClass.useAddon(addon);
+      });
+    }
+
+    return cloudClass;
+  }
+
   /**
    * Configures a class for working on Parse Cloud
    * @param P The Parse Cloud Object
@@ -261,7 +368,7 @@ export default class ParseCloudClass implements IParseCloudClass {
       }
 
       req.object = await this.processBeforeSave(req);
-      if (res) {
+      if (res && res.success) {
         (res as any).success(req.object);
       } else {
         return req.object;

test/cloud/AnalyticAddon.js renamed to src/test/cloud/AnalyticAddon.js

@@ -1,5 +1,5 @@
 const Parse = require('parse/node');
-const { ParseCloudClass } = require('../../src');
+const { ParseCloudClass } = require('../../');
 
 class AnalyticAddon extends ParseCloudClass {
   async afterSave(req) {

test/cloud/TestAddon.js renamed to src/test/cloud/TestAddon.js

@@ -1,4 +1,4 @@
-const { ParseCloudClass } = require('../../src');
+const { ParseCloudClass } = require('../../');
 
 /**
  * Sets the key 'testAddonProcessed' to true

test/cloud/main.js renamed to src/test/cloud/main.js

@@ -1,4 +1,4 @@
-const { ParseCloudClass } = require('../../src');
+const { ParseCloudClass } = require('../../');
 const TestAddon = require('./TestAddon');
 const AnalyticAddon = require('./AnalyticAddon');
 

test/index.integration.test.ts renamed to src/test/index.integration.test.ts

@@ -1,6 +1,7 @@
 // @ts-check
 import * as Parse from 'parse/node';
-import { ParseCloudClass } from '../src/index';
+import { ParseCloudClass } from '../index';
+import { ICloudClassObject } from '../ParseCloudClass';
 
 class ExtendedParseClass extends ParseCloudClass {
   requiredKeys = ['name', 'creditCard', 'description'];
@@ -610,3 +611,99 @@ describe('Working with addons', () => {
   });
 
 });
+
+describe('Given a configuration object', () => {
+  const spyFind = jest.fn();
+  const spyBeforeSave = jest.fn();
+  const spyAfterSave = jest.fn();
+  const spyBeforeDelete = jest.fn();
+  const spyAfterDelete = jest.fn();
+
+  const object: ICloudClassObject = {
+    addons: [new ParseCloudClass()],
+    defaultValues: {
+      test: true,
+    },
+    beforeFind: function (req) {
+      spyFind(this);
+      return req.query;
+    },
+    processBeforeSave: async function (req) {
+      spyBeforeSave(this);
+      return req.object;
+    },
+    afterSave: async function (req) {
+      spyAfterSave(this);
+      return req.object;
+    },
+    processBeforeDelete: async function (req) {
+      spyBeforeDelete(this);
+      return req.object;
+    },
+    afterDelete: async function (req) {
+      spyAfterDelete(this);
+      return req.object;
+    },
+  };
+
+  const instance = ParseCloudClass.fromObject(object);
+
+  test('should return a instance of ParseCloudClass', () => {
+    expect(instance).toBeInstanceOf(ParseCloudClass);
+  });
+
+  describe('Calling beforeFind', () => {
+    test('should call the mock function', () => {
+      instance.beforeFind({ query: new Parse.Query('Test') });
+      expect(spyFind).toHaveBeenCalledTimes(1);
+    });
+
+    test('"this" must reference the instance', () => {
+      expect(spyFind.mock.calls[0][0].defaultValues).toEqual(object.defaultValues);
+    });
+  });
+
+  describe('Calling processBeforeSave', () => {
+    test('should call the mock function', async () => {
+      await instance.processBeforeSave({ object: new Parse.Object('Test') });
+      expect(spyBeforeSave).toHaveBeenCalledTimes(1);
+    });
+
+    test('"this" must reference the instance', () => {
+      expect(spyBeforeSave.mock.calls[0][0].defaultValues).toEqual(object.defaultValues);
+    });
+  });
+
+  describe('Calling afterSave', () => {
+    test('should call the mock function', async () => {
+      await instance.afterSave({ object: new Parse.Object('Test') });
+      expect(spyAfterSave).toHaveBeenCalledTimes(1);
+    });
+
+    test('"this" must reference the instance', () => {
+      expect(spyAfterSave.mock.calls[0][0].defaultValues).toEqual(object.defaultValues);
+    });
+  });
+
+  describe('Calling processBeforeDelete', () => {
+    test('should call the mock function', async () => {
+      await instance.processBeforeDelete({ object: new Parse.Object('Test') });
+      expect(spyBeforeDelete).toHaveBeenCalledTimes(1);
+    });
+
+    test('"this" must reference the instance', () => {
+      expect(spyBeforeDelete.mock.calls[0][0].defaultValues).toEqual(object.defaultValues);
+    });
+  });
+
+  describe('Calling afterDelete', () => {
+    test('should call the mock function', async () => {
+      await instance.afterDelete({ object: new Parse.Object('Test') });
+      expect(spyAfterDelete).toHaveBeenCalledTimes(1);
+    });
+
+    test('"this" must reference the instance', () => {
+      expect(spyAfterDelete.mock.calls[0][0].defaultValues).toEqual(object.defaultValues);
+    });
+  });
+});

test/index.test.ts renamed to src/test/index.test.ts

@@ -1,5 +1,5 @@
-import { ParseCloudClass } from '../../src';
-import requireKey from '../../src/decorators/requireKey';
+import { ParseCloudClass } from '../../';
+import requireKey from '../../decorators/requireKey';
 
 @requireKey('testKey', 'testKey38')
 class TestClass extends ParseCloudClass {

test/util/requireKey.test.ts renamed to src/test/util/requireKey.test.ts

@@ -1,5 +1,5 @@
 import * as Parse from 'parse/node';
-import requireLogin, { PLEASE_LOGIN } from '../../src/util/requireLogin';
+import requireLogin, { PLEASE_LOGIN } from '../../util/requireLogin';
 
 test('Given a request with no user nor master key: should throw', () => {
   expect(() => {

test/util/requireLogin.test.ts renamed to src/test/util/requireLogin.test.ts

@@ -14,7 +14,6 @@
   },
   "exclude": [
     "node_modules",
-    "test",
     "out"
   ]
 }