add lib folder

Author: alenoir

.gitignore

@@ -37,7 +37,7 @@ node_modules
 .vscode
 
 # Babel.js
-lib/
+#lib/
 
 # cache folder
 .cache

lib/Adapters/AdapterLoader.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadAdapter = loadAdapter;
+function loadAdapter(adapter, defaultAdapter, options) {
+  if (!adapter) {
+    if (!defaultAdapter) {
+      return options;
+    }
+    // Load from the default adapter when no adapter is set
+    return loadAdapter(defaultAdapter, undefined, options);
+  } else if (typeof adapter === "function") {
+    try {
+      return adapter(options);
+    } catch (e) {
+      if (e.name === 'TypeError') {
+        var Adapter = adapter;
+        return new Adapter(options);
+      } else {
+        throw e;
+      }
+    }
+  } else if (typeof adapter === "string") {
+    adapter = require(adapter);
+    // If it's define as a module, get the default
+    if (adapter.default) {
+      adapter = adapter.default;
+    }
+    return loadAdapter(adapter, undefined, options);
+  } else if (adapter.module) {
+    return loadAdapter(adapter.module, undefined, adapter.options);
+  } else if (adapter.class) {
+    return loadAdapter(adapter.class, undefined, adapter.options);
+  } else if (adapter.adapter) {
+    return loadAdapter(adapter.adapter, undefined, adapter.options);
+  }
+  // return the adapter as provided
+  return adapter;
+}
+
+exports.default = loadAdapter;

lib/Adapters/Analytics/AnalyticsAdapter.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var AnalyticsAdapter = exports.AnalyticsAdapter = function () {
+  function AnalyticsAdapter() {
+    _classCallCheck(this, AnalyticsAdapter);
+  }
+
+  _createClass(AnalyticsAdapter, [{
+    key: "appOpened",
+    value: function appOpened(parameters, req) {
+      return Promise.resolve({});
+    }
+  }, {
+    key: "trackEvent",
+    value: function trackEvent(eventName, parameters, req) {
+      return Promise.resolve({});
+    }
+  }]);
+
+  return AnalyticsAdapter;
+}();
+
+exports.default = AnalyticsAdapter;

lib/Adapters/Cache/CacheAdapter.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var CacheAdapter = exports.CacheAdapter = function () {
+  function CacheAdapter() {
+    _classCallCheck(this, CacheAdapter);
+  }
+
+  _createClass(CacheAdapter, [{
+    key: "get",
+
+    /**
+     * Get a value in the cache
+     * @param key Cache key to get
+     * @return Promise that will eventually resolve to the value in the cache.
+     */
+    value: function get(key) {}
+
+    /**
+     * Set a value in the cache
+     * @param key Cache key to set
+     * @param value Value to set the key
+     * @param ttl Optional TTL
+     */
+
+  }, {
+    key: "put",
+    value: function put(key, value, ttl) {}
+
+    /**
+     * Remove a value from the cache.
+     * @param key Cache key to remove
+     */
+
+  }, {
+    key: "del",
+    value: function del(key) {}
+
+    /**
+     * Empty a cache
+     */
+
+  }, {
+    key: "clear",
+    value: function clear() {}
+  }]);
+
+  return CacheAdapter;
+}();

lib/Adapters/Cache/InMemoryCache.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var DEFAULT_CACHE_TTL = 5 * 1000;
+
+var InMemoryCache = exports.InMemoryCache = function () {
+  function InMemoryCache(_ref) {
+    var _ref$ttl = _ref.ttl;
+    var ttl = _ref$ttl === undefined ? DEFAULT_CACHE_TTL : _ref$ttl;
+
+    _classCallCheck(this, InMemoryCache);
+
+    this.ttl = ttl;
+    this.cache = Object.create(null);
+  }
+
+  _createClass(InMemoryCache, [{
+    key: "get",
+    value: function get(key) {
+      var record = this.cache[key];
+      if (record == null) {
+        return null;
+      }
+
+      // Has Record and isnt expired
+      if (isNaN(record.expire) || record.expire >= Date.now()) {
+        return record.value;
+      }
+
+      // Record has expired
+      delete this.cache[key];
+      return null;
+    }
+  }, {
+    key: "put",
+    value: function put(key, value) {
+      var _this = this;
+
+      var ttl = arguments.length <= 2 || arguments[2] === undefined ? this.ttl : arguments[2];
+
+      if (ttl < 0 || isNaN(ttl)) {
+        ttl = NaN;
+      }
+
+      var record = {
+        value: value,
+        expire: ttl + Date.now()
+      };
+
+      if (!isNaN(record.expire)) {
+        record.timeout = setTimeout(function () {
+          _this.del(key);
+        }, ttl);
+      }
+
+      this.cache[key] = record;
+    }
+  }, {
+    key: "del",
+    value: function del(key) {
+      var record = this.cache[key];
+      if (record == null) {
+        return;
+      }
+
+      if (record.timeout) {
+        clearTimeout(record.timeout);
+      }
+      delete this.cache[key];
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.cache = Object.create(null);
+    }
+  }]);
+
+  return InMemoryCache;
+}();
+
+exports.default = InMemoryCache;

lib/Adapters/Cache/InMemoryCacheAdapter.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryCacheAdapter = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _InMemoryCache = require('./InMemoryCache');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var InMemoryCacheAdapter = exports.InMemoryCacheAdapter = function () {
+  function InMemoryCacheAdapter(ctx) {
+    _classCallCheck(this, InMemoryCacheAdapter);
+
+    this.cache = new _InMemoryCache.InMemoryCache(ctx);
+  }
+
+  _createClass(InMemoryCacheAdapter, [{
+    key: 'get',
+    value: function get(key) {
+      var _this = this;
+
+      return new Promise(function (resolve, reject) {
+        var record = _this.cache.get(key);
+        if (record == null) {
+          return resolve(null);
+        }
+
+        return resolve(JSON.parse(record));
+      });
+    }
+  }, {
+    key: 'put',
+    value: function put(key, value, ttl) {
+      this.cache.put(key, JSON.stringify(value), ttl);
+      return Promise.resolve();
+    }
+  }, {
+    key: 'del',
+    value: function del(key) {
+      this.cache.del(key);
+      return Promise.resolve();
+    }
+  }, {
+    key: 'clear',
+    value: function clear() {
+      this.cache.clear();
+      return Promise.resolve();
+    }
+  }]);
+
+  return InMemoryCacheAdapter;
+}();
+
+exports.default = InMemoryCacheAdapter;

lib/Adapters/Email/MailAdapter.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/*
+  Mail Adapter prototype
+  A MailAdapter should implement at least sendMail()
+ */
+var MailAdapter = exports.MailAdapter = function () {
+  function MailAdapter() {
+    _classCallCheck(this, MailAdapter);
+  }
+
+  _createClass(MailAdapter, [{
+    key: "sendMail",
+
+    /*
+     * A method for sending mail
+     * @param options would have the parameters
+     * - to: the recipient
+     * - text: the raw text of the message
+     * - subject: the subject of the email
+     */
+    value: function sendMail(options) {}
+
+    /* You can implement those methods if you want
+     * to provide HTML templates etc...
+     */
+    // sendVerificationEmail({ link, appName, user }) {}
+    // sendPasswordResetEmail({ link, appName, user }) {}
+
+  }]);
+
+  return MailAdapter;
+}();
+
+exports.default = MailAdapter;

lib/Adapters/Files/FilesAdapter.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+// Files Adapter
+//
+// Allows you to change the file storage mechanism.
+//
+// Adapter classes must implement the following functions:
+// * createFile(config, filename, data)
+// * getFileData(config, filename)
+// * getFileLocation(config, request, filename)
+//
+// Default is GridStoreAdapter, which requires mongo
+// and for the API server to be using the DatabaseController with Mongo
+// database adapter.
+
+var FilesAdapter = exports.FilesAdapter = function () {
+  function FilesAdapter() {
+    _classCallCheck(this, FilesAdapter);
+  }
+
+  _createClass(FilesAdapter, [{
+    key: "createFile",
+
+    /* this method is responsible to store the file in order to be retrived later by it's file name
+     *
+     * @param filename the filename to save
+     * @param data the buffer of data from the file
+     * @param contentType the supposed contentType
+     * @discussion the contentType can be undefined if the controller was not able to determine it
+     *
+     * @return a promise that should fail if the storage didn't succeed
+     *
+     */
+    value: function createFile(filename, data, contentType) {}
+  }, {
+    key: "deleteFile",
+    value: function deleteFile(filename) {}
+  }, {
+    key: "getFileData",
+    value: function getFileData(filename) {}
+  }, {
+    key: "getFileLocation",
+    value: function getFileLocation(config, filename) {}
+  }]);
+
+  return FilesAdapter;
+}();
+
+exports.default = FilesAdapter;