- add an option to disable getting DataTable classes from the global scope

Author: Valodya

backendless.d.ts

@@ -4,6 +4,7 @@
  */
 declare module Backendless {
     let debugMode: boolean;
+    let useTableClassesFromGlobalScope: boolean;
     let serverURL: string;
     let appId: string;
     let apiKey: string;
@@ -35,7 +36,8 @@ declare module Backendless {
         serverURL?: string;
         domain?: string;
         debugMode?: boolean;
-        XMLHttpRequest?: XMLHttpRequest,
+        XMLHttpRequest?: XMLHttpRequest;
+        useTableClassesFromGlobalScope?: boolean;
     }
 
     /**

src/data/store.js

@@ -312,14 +312,14 @@ export default class DataStore {
    * @private
    * */
   parseRelationsResponse(result, RelationModel) {
-    return convertToClientRecords(result, RelationModel, this.classToTableMap)
+    return convertToClientRecords(result, RelationModel, this)
   }
 
   /**
    * @private
    * */
   parseResponse(result) {
-    return convertToClientRecords(result, this.model, this.classToTableMap)
+    return convertToClientRecords(result, this.model, this)
   }
 
   /**
@@ -419,16 +419,17 @@ const convertToServerRecord = (() => {
 })()
 
 const convertToClientRecords = (() => {
-  return (records, RootModel, classToTableMap) => {
+  return (records, RootModel, dataStore) => {
     if (!records) {
       return records
     }
 
     const context = {
       RootModel,
-      classToTableMap,
-      subIds    : {},
-      postAssign: [],
+      app            : dataStore.app,
+      classToTableMap: dataStore.classToTableMap,
+      subIds         : {},
+      postAssign     : [],
     }
 
     const result = Array.isArray(records)
@@ -448,7 +449,19 @@ const convertToClientRecords = (() => {
       delete source[prop].__subID
 
     } else {
-      const Model = context.classToTableMap[source[prop].___class] || Utils.globalScope[source[prop].___class]
+      let Model = context.classToTableMap[source[prop].___class]
+
+      if (!Model && context.app.useTableClassesFromGlobalScope && Utils.globalScope[source[prop].___class]) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'Resolving DataTable classes from the global scope is deprecated ' +
+          'and it won\'t be supported in the nearest future. ' +
+          'Instead, you should register your DataTable classes ' +
+          'using the following method Backendless.Data.mapTableToClass'
+        )
+
+        Model = Utils.globalScope[source[prop].___class]
+      }
 
       target[prop] = Model ? new Model() : {}
 

src/index.js

@@ -15,6 +15,10 @@ const DEFAULT_PROPS = {
   XMLHttpRequest: typeof XMLHttpRequest !== 'undefined'
     ? XMLHttpRequest
     : undefined,
+
+  //TODO: this is a temporary to disable getting DataTable classes from the global scope
+  //TODO: it will be removed in the nearest future
+  useTableClassesFromGlobalScope: true,
 }
 
 const STATELESS_PROPS = ['appId', 'apiKey', 'domain']
@@ -255,6 +259,15 @@ class Backendless {
     )
   }
 
+  ///--------useTableClassesFromGlobalScope-------///
+  get useTableClassesFromGlobalScope() {
+    return this.__useTableClassesFromGlobalScope
+  }
+
+  set useTableClassesFromGlobalScope(useTableClassesFromGlobalScope) {
+    this.__useTableClassesFromGlobalScope = !!useTableClassesFromGlobalScope
+  }
+
   ///--------debugMode-------///
   get debugMode() {
     return this.__debugMode

test/tsd.ts

@@ -23,6 +23,7 @@ function testMain() {
         apiKey: 'JS_SECRET_KEY',
         standalone: true,
         debugMode: true,
+        useTableClassesFromGlobalScope: false,
         serverURL: 'serverURL'
     });
 

test/unit/specs/data/parser.js

@@ -2794,7 +2794,13 @@ describe('<Data> Parser', function() {
     expect(result2[1]).to.be.instanceof(FooClass)
   })
 
-  it('data store object with inner instances from global', async () => {
+  it('uses classes from global by default for data store object with inner instances', async () => {
+    // eslint-disable-next-line no-console
+    const _nativeConsoleWarn = console.warn
+
+    // eslint-disable-next-line no-console
+    const spyConsoleWarn = console.warn = chai.spy()
+
     global.FooClass = class FooClass {
     }
 
@@ -2831,6 +2837,77 @@ describe('<Data> Parser', function() {
 
     expect(result2[1].foo).to.be.instanceof(FooClass)
     expect(result2[1].bar).to.be.instanceof(BarFun)
+
+    expect(spyConsoleWarn).to.have.been.called.exactly(6)
+
+    const warningMsg = (
+      'Resolving DataTable classes from the global scope is deprecated ' +
+      'and it won\'t be supported in the nearest future. ' +
+      'Instead, you should register your DataTable classes ' +
+      'using the following method Backendless.Data.mapTableToClass'
+    )
+
+    expect(spyConsoleWarn).on.nth(1).be.called.with(warningMsg)
+    expect(spyConsoleWarn).on.nth(2).be.called.with(warningMsg)
+    expect(spyConsoleWarn).on.nth(3).be.called.with(warningMsg)
+    expect(spyConsoleWarn).on.nth(4).be.called.with(warningMsg)
+    expect(spyConsoleWarn).on.nth(5).be.called.with(warningMsg)
+    expect(spyConsoleWarn).on.nth(6).be.called.with(warningMsg)
+
+    // eslint-disable-next-line no-console
+    console.warn = _nativeConsoleWarn
+  })
+
+  it('does not use classes from global for data store object with inner instances', async () => {
+    // eslint-disable-next-line no-console
+    const _nativeConsoleWarn = console.warn
+
+    // eslint-disable-next-line no-console
+    const spyConsoleWarn = console.warn = chai.spy()
+
+    Backendless.useTableClassesFromGlobalScope = false
+
+    global.FooClass = class FooClass {
+    }
+
+    global.BarFun = function BarFun() {
+    }
+
+    dataStore = Backendless.Data.of(tableName)
+
+    const result1 = dataStore.parseResponse({
+      foo: { ___class: 'FooClass', value: 1, },
+      bar: { ___class: 'BarFun', value: 2, }
+    })
+
+    const result2 = dataStore.parseResponse([
+      { foo: { ___class: 'FooClass', value: 3, }, bar: { ___class: 'BarFun', value: 5, } },
+      { foo: { ___class: 'FooClass', value: 4, }, bar: { ___class: 'BarFun', value: 6, } }
+    ])
+
+    expect(result1).to.be.eql({
+      foo: { ___class: 'FooClass', value: 1, },
+      bar: { ___class: 'BarFun', value: 2, }
+    })
+
+    expect(result1.foo).to.not.be.instanceof(FooClass)
+    expect(result1.bar).to.not.be.instanceof(BarFun)
+
+    expect(result2).to.be.eql([
+      { foo: { ___class: 'FooClass', value: 3, }, bar: { ___class: 'BarFun', value: 5, } },
+      { foo: { ___class: 'FooClass', value: 4, }, bar: { ___class: 'BarFun', value: 6, } }
+    ])
+
+    expect(result2[0].foo).to.not.be.instanceof(FooClass)
+    expect(result2[0].bar).to.not.be.instanceof(BarFun)
+
+    expect(result2[1].foo).to.not.be.instanceof(FooClass)
+    expect(result2[1].bar).to.not.be.instanceof(BarFun)
+
+    expect(spyConsoleWarn).to.have.been.called.exactly(0)
+
+    // eslint-disable-next-line no-console
+    console.warn = _nativeConsoleWarn
   })
 
   it('data store object with inner instances from classesMap', async () => {