backendless/es/index.js

Backendless JavaScript SDK for Node.js and the browser

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _backendlessRequest = _interopRequireDefault(require("backendless-request"));
var _request = _interopRequireDefault(require("./request"));
var _urls = _interopRequireDefault(require("./urls"));
var _utils = _interopRequireDefault(require("./utils"));
var _expression = _interopRequireDefault(require("./expression"));
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
var DEFAULT_PROPS = {
  appId: null,
  apiKey: null,
  serverURL: 'https://api.backendless.com',
  automationServerURL: null,
  domain: null,
  apiURI: '/api',
  debugMode: false,
  standalone: false,
  XMLHttpRequest: typeof XMLHttpRequest !== 'undefined' ? XMLHttpRequest : undefined
};
var STATELESS_PROPS = ['appId', 'apiKey', 'domain'];
var previousBackendless = _utils["default"].globalScope && _utils["default"].globalScope.Backendless;
var showLegacyDataWarning = function showLegacyDataWarning() {
  if (!showLegacyDataWarning.isShown) {
    // eslint-disable-next-line no-console
    console.warn('Backendless.Persistence is deprecated namespace, use Backendless.Data instead');
    showLegacyDataWarning.isShown = true;
  }
};

// Backendless supports three signatures for the initApp method
// two args - applicationId {String} and secretKey {String}
// one argument - domain {String}
// one argument - whole set of options {Object}
var parseInitConfig = function parseInitConfig() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  var appId = args[0],
    apiKey = args[1];
  if (appId && (0, _typeof2["default"])(appId) === 'object') {
    return appId;
  }
  if (typeof appId === 'string' && !apiKey) {
    return {
      domain: appId
    };
  }
  return {
    appId: appId,
    apiKey: apiKey
  };
};
var validateConfig = function validateConfig(config) {
  if (config.domain) {
    if (!config.domain.startsWith('https://') && !config.domain.startsWith('http://')) {
      throw new Error('When initialize the SDK with a custom domain it should start with http:// or https://, ' + 'for example: Backendless.initApp(\'https://foobar.com\')');
    }
  }
};
var SERVICES = {
  'Logging': function Logging() {
    return require('./logging')["default"];
  },
  'Counters': function Counters() {
    return require('./counters')["default"];
  },
  'Cache': function Cache() {
    return require('./cache')["default"];
  },
  'Commerce': function Commerce() {
    return require('./commerce')["default"];
  },
  'Users': function Users() {
    return require('./users')["default"];
  },
  'BL': function BL() {
    return require('./bl')["default"];
  },
  'Data': function Data() {
    return require('./data')["default"];
  },
  'Hive': function Hive() {
    return require('./hive')["default"];
  },
  'Messaging': function Messaging() {
    return require('./messaging')["default"];
  },
  'Files': function Files() {
    return require('./files')["default"];
  },
  'RT': function RT() {
    return require('./rt')["default"];
  },
  'SharedObject': function SharedObject() {
    return require('./rso')["default"];
  },
  'LocalCache': function LocalCache() {
    return require('./local-cache')["default"];
  },
  'UnitOfWork': function UnitOfWork() {
    return require('./unit-of-work')["default"];
  },
  'Management': function Management() {
    return require('./management')["default"];
  },
  'Automations': function Automations() {
    return require('./automations')["default"];
  }
};
var Backendless = /*#__PURE__*/function () {
  function Backendless(props) {
    (0, _classCallCheck2["default"])(this, Backendless);
    this.initConfig(props);
    this.Request = _backendlessRequest["default"];
    this.request = new _request["default"](this);
    this.urls = new _urls["default"](this);
  }

  /**
   * @param {Object} config
   */
  (0, _createClass2["default"])(Backendless, [{
    key: "initConfig",
    value: function initConfig(config) {
      config = _objectSpread({}, config);
      if (config.domain) {
        delete config.appId;
        delete config.apiKey;
      }
      for (var key in DEFAULT_PROPS) {
        if (DEFAULT_PROPS.hasOwnProperty(key)) {
          var privateKey = "__".concat(key);
          if (STATELESS_PROPS.includes(key)) {
            delete this[privateKey];
          }
          var defaultValue = this[privateKey] === undefined ? DEFAULT_PROPS[key] : this[privateKey];
          this[privateKey] = config[key] === undefined ? defaultValue : config[key];
        }
      }
    }

    /**
     * @param {string|Object} appId|domain|config
     * @param {string} [apiKey]
     * @returns {Backendless}
     */
  }, {
    key: "initApp",
    value: function initApp() {
      var config = parseInitConfig.apply(void 0, arguments);
      validateConfig(config);
      var app = config.standalone ? new Backendless(this) : this;
      app.initConfig(config);
      app.resetRT();
      app.__removeService('LocalCache');
      app.appInfoPromise();
      var loggingConfig = (0, _extends2["default"])({
        loadLevels: true,
        globalLevel: 'all',
        levels: {}
      }, config.logging);
      if (app.__hasService('Logging')) {
        app.Logging.reset();
        app.Logging.setConfig(loggingConfig);
      }
      if (app.__hasService('Users')) {
        app.Users.currentUser = null;
      }
      delete this.__device;
      app.loggingConfig = loggingConfig;
      return app;
    }
  }, {
    key: "appInfoPromise",
    value: function appInfoPromise(reset) {
      var _this = this;
      if (reset || !this.__appInfoPromise) {
        this.__appInfoPromise = new Promise(function (resolve, reject) {
          _this.request.get({
            url: _this.urls.appInfo()
          }).then(resolve)["catch"](function (error) {
            if (error.code === 3064) {
              _this.setCurrentUserToken(null);
              return _this.request.get({
                url: _this.urls.appInfo()
              });
            }
            throw error;
          })["catch"](reject);
        });
      }
      this.__appInfoPromise["catch"](function (error) {
        // eslint-disable-next-line no-console
        console.error('could not load backendless app info', error);
      });
      return this.__appInfoPromise;
    }
  }, {
    key: "__hasService",
    value: function __hasService(name) {
      return !!this["__".concat(name)];
    }
  }, {
    key: "__removeService",
    value: function __removeService(name) {
      delete this["__".concat(name)];
    }
  }, {
    key: "__getService",
    value: function __getService(name) {
      var privateName = "__".concat(name);
      if (!this[privateName]) {
        var Service = SERVICES[name]();
        this[privateName] = new Service(this);
      }
      return this[privateName];
    }

    ///--------SETTERS/GETTERS-------///

    ///--------standalone-------///
  }, {
    key: "standalone",
    get: function get() {
      return this.__standalone;
    },
    set: function set(standalone) {
      throw new Error('Setting value to Backendless.standalone directly is not possible, ' + "instead you must use Backendless.initApp({ appId: [APP_ID], apiKey: [API_KEY], standalone: ".concat(standalone, " })"));
    }
  }, {
    key: "appId",
    get: function get() {
      return this.__appId;
    },
    set: function set(appId) {
      throw new Error("Setting '".concat(appId, "' value to Backendless.appId directly is not possible, ") + "instead you must use Backendless.initApp('".concat(appId, "', API_KEY)"));
    }
  }, {
    key: "apiKey",
    get: function get() {
      return this.__apiKey;
    },
    set: function set(apiKey) {
      throw new Error("Setting '".concat(apiKey, "' value to Backendless.apiKey directly is not possible, ") + "instead you must use Backendless.initApp(APP_ID, '".concat(apiKey, "')"));
    }

    ///--------serverURL-------///
  }, {
    key: "serverURL",
    get: function get() {
      return this.__serverURL;
    },
    set: function set(url) {
      this.__serverURL = url;
    }

    ///--------automationServerURL-------///
  }, {
    key: "automationServerURL",
    get: function get() {
      return this.__automationServerURL;
    },
    set: function set(url) {
      this.__automationServerURL = url;
    }

    ///--------domain-------///
  }, {
    key: "domain",
    get: function get() {
      return this.__domain;
    },
    set: function set(domain) {
      this.__domain = domain;
    }

    ///--------apiURI-------///
  }, {
    key: "apiURI",
    get: function get() {
      return this.__apiURI;
    },
    set: function set(apiURI) {
      this.__apiURI = apiURI;
    }

    ///--------appPath-------///
  }, {
    key: "appPath",
    get: function get() {
      if (this.domain) {
        return this.domain + this.apiURI;
      }
      if (this.appId && this.apiKey) {
        return [this.serverURL, this.appId, this.apiKey].join('/');
      }
      return null;
    },
    set: function set(appPath) {
      throw new Error("Setting '".concat(appPath, "' value to Backendless.appPath directly is not possible, ") + 'instead you must use Backendless.initApp(APP_ID, API_KEY) for setup the value');
    }
  }, {
    key: "automationPath",
    get: function get() {
      if (!this.automationServerURL) {
        return this.appPath;
      }
      return [this.automationServerURL, this.appId, this.apiKey].join('/');
    },
    set: function set(automationPath) {
      throw new Error("Setting '".concat(automationPath, "' value to Backendless.automationPath directly is not possible"));
    }

    ///--------debugMode-------///
  }, {
    key: "debugMode",
    get: function get() {
      return this.__debugMode;
    },
    set: function set(debugMode) {
      debugMode = !!debugMode;
      if (this.__debugMode !== debugMode) {
        this.__debugMode = debugMode;
        if (this.__RT) {
          this.RT.setDebugMode(debugMode);
        }
      }
    }

    ///--------XMLHttpRequestMode-------///
  }, {
    key: "XMLHttpRequest",
    get: function get() {
      return this.__XMLHttpRequest;
    },
    set: function set(XMLHttpRequest) {
      this.__XMLHttpRequest = XMLHttpRequest;
    }

    ///--------device-------///
  }, {
    key: "device",
    get: function get() {
      if (!this.__device) {
        throw new Error('Device is not defined. Please, run the Backendless.setupDevice');
      }
      return this.__device;
    },
    set: function set(props) {
      throw new Error('Setting value to Backendless.device directly is not possible, ' + 'instead you must use Backendless.setupDevice(deviceProperties) for setup the device');
    }
  }, {
    key: "setupDevice",
    value: function setupDevice(device) {
      var Device = require('./device')["default"];
      this.__device = new Device(device);
    }

    ///----------UTIL METHODS--------///
  }, {
    key: "Utils",
    get: function get() {
      return _utils["default"];
    }
  }, {
    key: "getCurrentUserToken",
    value: function getCurrentUserToken() {
      return this.Users.getCurrentUserToken();
    }
  }, {
    key: "setCurrentUserToken",
    value: function setCurrentUserToken(userToken) {
      this.Users.setCurrentUserToken(userToken);
    }
  }, {
    key: "browser",
    get: function get() {
      return require('./user-agent').getUserAgent();
    }
  }, {
    key: "noConflict",
    value: function noConflict() {
      if (_utils["default"].globalScope) {
        _utils["default"].globalScope.Backendless = previousBackendless;
      }
      return this;
    }

    ///-------------------------------------///
    ///-------------- SERVICES -------------///
  }, {
    key: "Logging",
    get: function get() {
      return this.__getService('Logging');
    }
  }, {
    key: "Counters",
    get: function get() {
      return this.__getService('Counters');
    }
  }, {
    key: "Cache",
    get: function get() {
      return this.__getService('Cache');
    }
  }, {
    key: "Commerce",
    get: function get() {
      return this.__getService('Commerce');
    }
  }, {
    key: "Users",
    get: function get() {
      return this.__getService('Users');
    }
  }, {
    key: "User",
    get: function get() {
      return require('./users/user')["default"];
    }
  }, {
    key: "UserService",
    get: function get() {
      return this.Users;
    }
  }, {
    key: "BL",
    get: function get() {
      return this.__getService('BL');
    }
  }, {
    key: "CustomServices",
    get: function get() {
      return this.BL.CustomServices;
    }
  }, {
    key: "APIServices",
    get: function get() {
      return this.BL.CustomServices;
    }
  }, {
    key: "Events",
    get: function get() {
      return this.BL.Events;
    }
  }, {
    key: "Data",
    get: function get() {
      return this.__getService('Data');
    }
  }, {
    key: "Hive",
    get: function get() {
      return this.__getService('Hive');
    }
  }, {
    key: "Messaging",
    get: function get() {
      return this.__getService('Messaging');
    }
  }, {
    key: "Files",
    get: function get() {
      return this.__getService('Files');
    }
  }, {
    key: "RT",
    get: function get() {
      return this.__getService('RT');
    }
  }, {
    key: "resetRT",
    value: function resetRT() {
      if (this.__RT) {
        this.__RT.terminate();
        delete this.__RT;
      }
    }
  }, {
    key: "SharedObject",
    get: function get() {
      return this.__getService('SharedObject');
    }
  }, {
    key: "LocalCache",
    get: function get() {
      return this.__getService('LocalCache');
    }
  }, {
    key: "UnitOfWork",
    get: function get() {
      return this.__getService('UnitOfWork');
    }
  }, {
    key: "Management",
    get: function get() {
      return this.__getService('Management');
    }
  }, {
    key: "Automations",
    get: function get() {
      return this.__getService('Automations');
    }

    ///-------------- SERVICES -------------///
    ///-------------------------------------///

    ///-------------------------------------///
    ///--------BACKWARD COMPATIBILITY-------///

    /** @deprecated */
  }, {
    key: "applicationId",
    get: function get() {
      // eslint-disable-next-line no-console
      // temporary comment it because it breaks JS-CodeRunner version less than 6.3.0
      // console.warn('getter/setter for Backendless.applicationId is deprecated, instead use Backendless.appId')

      return this.appId;
    }

    /** @deprecated */,
    set: function set(appId) {
      // eslint-disable-next-line no-console
      console.warn('getter/setter for Backendless.applicationId is deprecated, instead use Backendless.appId');
      this.appId = appId;
    }

    /** @deprecated */
  }, {
    key: "secretKey",
    get: function get() {
      // eslint-disable-next-line no-console
      console.warn('getter/setter for Backendless.secretKey is deprecated, instead use Backendless.apiKey');
      return this.apiKey;
    }

    /** @deprecated */,
    set: function set(apiKey) {
      // eslint-disable-next-line no-console
      console.warn('getter/setter for Backendless.secretKey is deprecated, instead use Backendless.apiKey');
      this.apiKey = apiKey;
    }

    /** @deprecated */
  }, {
    key: "Persistence",
    get: function get() {
      showLegacyDataWarning();
      return this.Data;
    }
  }, {
    key: "DataQueryBuilder",
    get: function get() {
      return this.Data.QueryBuilder;
    }
  }, {
    key: "GroupQueryBuilder",
    get: function get() {
      return this.Data.GroupQueryBuilder;
    }
  }, {
    key: "JSONUpdateBuilder",
    get: function get() {
      return this.Data.JSONUpdateBuilder;
    }
  }, {
    key: "LoadRelationsQueryBuilder",
    get: function get() {
      return this.Data.LoadRelationsQueryBuilder;
    }
  }, {
    key: "Bodyparts",
    get: function get() {
      return this.Messaging.Bodyparts;
    }
  }, {
    key: "PublishOptions",
    get: function get() {
      return this.Messaging.PublishOptions;
    }
  }, {
    key: "DeliveryOptions",
    get: function get() {
      return this.Messaging.DeliveryOptions;
    }
  }, {
    key: "PublishOptionsHeaders",
    get: function get() {
      return this.Messaging.PublishOptionsHeaders;
    }
  }, {
    key: "EmailEnvelope",
    get: function get() {
      return this.Messaging.EmailEnvelope;
    }
  }, {
    key: "Expression",
    get: function get() {
      return _expression["default"];
    }

    ///--------BACKWARD COMPATIBILITY-------///
    ///-------------------------------------///
  }]);
  return Backendless;
}();
var backendless = new Backendless(DEFAULT_PROPS);
if (_utils["default"].globalScope) {
  _utils["default"].globalScope.Backendless = backendless;
}
exports = module.exports = backendless;
var _default = backendless;
exports["default"] = _default;