@fleetbase/ember-core 0.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2022
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @fleetbase/ember-core
+
+Ember Core Services, Utilities and Framework for building Fleetbase Extensions in the Console
+
+
+## Compatibility
+
+* Ember.js v3.24 or above
+* Ember CLI v3.24 or above
+* Node.js v14 or above
+
+
+## Installation
+
+```
+ember install @fleetbase/ember-core
+```
+
+
+## Usage
+
+[Longer description of how to use the addon in apps.]
+
+
+## Contributing
+
+See the [Contributing](CONTRIBUTING.md) guide for details.
+
+
+## License
+
+This project is licensed under the [MIT License](LICENSE.md).

package/addon/adapters/application.js

@@ -0,0 +1,155 @@
+import RESTAdapter from '@ember-data/adapter/rest';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { storageFor } from 'ember-local-storage';
+import { get } from '@ember/object';
+import { isBlank } from '@ember/utils';
+import { dasherize } from '@ember/string';
+import { pluralize } from 'ember-inflector';
+import getUserOptions from '../utils/get-user-options';
+import config from 'ember-get-config';
+
+export default class ApplicationAdapter extends RESTAdapter {
+    /**
+     * Inject the `session` service
+     *
+     * @var {Service}
+     */
+    @service session;
+
+    /**
+     * Inject the `currentUser` service
+     *
+     * @var {Service}
+     */
+    @service currentUser;
+
+    /**
+     * User options for setting specific headers
+     *
+     * @var StorageObject
+     */
+    @storageFor('user-options') userOptions;
+
+    /**
+     * The default namespace for the adapter
+     *
+     * @var {String}
+     */
+    get host() {
+        return get(config, 'API.host');
+    }
+
+    /**
+     * The default namespace for adapter
+     *
+     * @var {String}
+     */
+    get namespace() {
+        return get(config, 'API.namespace');
+    }
+
+    /**
+     * Credentials
+     *
+     * @var {String}
+     */
+    credentials = 'include';
+
+    /**
+     * Mutable headers property.
+     *
+     * @var {Array}
+     */
+    @tracked _headers;
+
+    /**
+     * The headers to send with request.
+     *
+     * @var {Object}
+     */
+    get headers() {
+        if (this._headers) {
+            return this._headers;
+        }
+
+        return this.getHeaders();
+    }
+
+    /**
+     * Setter fucntion to overwrite headers.
+     */
+    set headers(headers) {
+        this._headers = headers;
+    }
+
+    /**
+     * Gets headers that should be sent with request.
+     *
+     * @return {Object}
+     */
+    getHeaders() {
+        const headers = {};
+        const isAuthenticated = this.session.isAuthenticated;
+        const userId = this.session.data.authenticated.user;
+        const userOptions = getUserOptions();
+        const isSandbox = get(userOptions, `${userId}:sandbox`) === true;
+        const testKey = get(userOptions, `${userId}:testKey`);
+
+        headers['Content-Type'] = 'application/json';
+
+        if (isAuthenticated) {
+            headers['Authorization'] = `Bearer ${this.session.data.authenticated.token}`;
+        }
+
+        if (isAuthenticated && isSandbox) {
+            headers['Access-Console-Sandbox'] = true;
+        }
+
+        if (isAuthenticated && !isBlank(testKey)) {
+            headers['Access-Console-Sandbox-Key'] = testKey;
+        }
+
+        return headers;
+    }
+
+    /**
+     * Gets fresh headers and sets them.
+     *
+     * @return {Object}
+     */
+    refreshHeaders() {
+        const headers = this.getHeaders();
+
+        this.headers = headers;
+
+        return headers;
+    }
+
+    /**
+     * Configure AJAX options for request, return as options hash
+     *
+     * @param {String} url
+     * @param {String} type The request type GET, POST, PUT, DELETE etc.
+     * @param {Object} options
+     *
+     * @return {Object}
+     */
+    ajaxOptions(url, type, options) {
+        this.refreshHeaders();
+
+        const ajaxOptions = super.ajaxOptions(url, type, options);
+        ajaxOptions.credentials = this.credentials;
+
+        return ajaxOptions;
+    }
+
+    /**
+     * Dasherize the path for type
+     *
+     * @param {Object} type
+     */
+    pathForType(type) {
+        return dasherize(pluralize(type));
+    }
+}

package/addon/adapters/user.js

@@ -0,0 +1,19 @@
+import ApplicationAdapter from './application';
+
+export default class UserAdapter extends ApplicationAdapter {
+    /**
+     * Set the URL path for users endpoints
+     *
+     * @param {object} query
+     * @return {String} originalUrl
+     */
+    urlForQueryRecord(query) {
+        let originalUrl = super.urlForQueryRecord(...arguments);
+        if (query.me) {
+            delete query.me;
+            return `${originalUrl}/me`;
+        }
+
+        return originalUrl;
+    }
+}

package/addon/authenticators/fleetbase.js

@@ -0,0 +1,72 @@
+import Base from 'ember-simple-auth/authenticators/base';
+import { inject as service } from '@ember/service';
+import { get } from '@ember/object';
+
+export default class FleetbaseAuthenticator extends Base {
+    /**
+     * Inject the `fetch` service
+     *
+     * @var {Service}
+     */
+    @service fetch;
+
+    /**
+     * Inject the `session` service
+     *
+     * @var {Service}
+     */
+    @service session;
+
+    /**
+     * Restore session from server
+     *
+     * @param {object} data
+     * @return {Promise}
+     */
+    restore(data) {
+        return this.fetch
+            .get(
+                'auth/session',
+                {},
+                {
+                    headers: {
+                        Authorization: `Bearer ${data.token}`,
+                    },
+                }
+            )
+            .then((response) => {
+                if (response.restore === false) {
+                    return Promise.reject(new Error(response.error));
+                }
+
+                return response;
+            });
+    }
+
+    /**
+     * Authenticates a users credentials
+     *
+     * @param {object} credentials
+     * @param {boolean} remember
+     * @param {string} path
+     */
+    authenticate(credentials = {}, remember = false, path = 'auth/login') {
+        return this.fetch.post(path, { ...credentials, remember }).then((response) => {
+            if (response.errors) {
+                return Promise.reject(new Error(response.errors.firstObject ?? 'Authentication failed!'));
+            }
+
+            return response;
+        });
+    }
+
+    /**
+     * Invalidates the current session
+     *
+     * @param {object} data
+     */
+    // eslint-disable-next-line no-unused-vars
+    invalidate(data) {
+        return this.fetch.post('auth/logout');
+    }
+}

package/addon/decorators/fetch-from.js

@@ -0,0 +1,55 @@
+import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
+import { assert } from '@ember/debug';
+import { getOwner } from '@ember/application';
+import { scheduleOnce } from '@ember/runloop';
+
+export default function fetchFrom(endpoint, query = {}, options = {}) {
+    assert('The first argument of the @fetchFrom decorator must be a string', typeof endpoint === 'string');
+    assert('The second argument of the @fetchFrom decorator must be an object', typeof query === 'object');
+    assert('The third argument of the @fetchFrom decorator must be an object', typeof options === 'object');
+
+    return decoratorWithRequiredParams(function (target, key, desc, params) {
+        const symbol = Symbol(`__${key}_fetchFrom`);
+
+        Object.defineProperty(target, symbol, {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: null,
+        });
+
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return this[symbol];
+            },
+            set(value) {
+                this[symbol] = value;
+            },
+        });
+
+        const originalInit = target.init;
+
+        target.init = function () {
+            if (originalInit) {
+                originalInit.call(this);
+            }
+
+            scheduleOnce('afterRender', this, function () {
+                const owner = getOwner(this);
+                const fetch = owner.lookup('service:fetch'); // Get the Fleetbase Fetch service
+
+                // Perform the query and set the result to the property
+                fetch
+                    .get(endpoint, query, options)
+                    .then((result) => {
+                        this.set(key, result);
+                    })
+                    .catch(() => {
+                        this.set(key, []);
+                    });
+            });
+        };
+    }, 'fetchFrom')(endpoint, query, options);
+}

package/addon/decorators/from-store.js

@@ -0,0 +1,56 @@
+import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
+import { assert } from '@ember/debug';
+import { get } from '@ember/object';
+import { getOwner } from '@ember/application';
+import { scheduleOnce } from '@ember/runloop';
+
+export default function fromStore(modelName, query = {}, options = {}) {
+    assert('The first argument of the @fromStore decorator must be a string', typeof modelName === 'string');
+    assert('The second argument of the @fromStore decorator must be an object', typeof query === 'object');
+    assert('The third argument of the @fromStore decorator must be an object', typeof options === 'object');
+
+    return decoratorWithRequiredParams(function (target, key, desc, params) {
+        const symbol = Symbol(`__${key}_fromStore`);
+
+        Object.defineProperty(target, symbol, {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: null,
+        });
+
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return this[symbol];
+            },
+            set(value) {
+                this[symbol] = value;
+            },
+        });
+
+        const originalInit = target.init;
+
+        target.init = function () {
+            if (originalInit) {
+                originalInit.call(this);
+            }
+
+            scheduleOnce('afterRender', this, function () {
+                const owner = getOwner(this);
+                const store = owner.lookup('service:store'); // Get the Ember Data store
+
+                // Perform the query and set the result to the property
+                store
+                    .query(modelName, query, options)
+                    .then((result) => {
+                        this.set(key, result);
+                    })
+                    .catch(() => {
+                        this.set(key, []);
+                    });
+            });
+        };
+    }, 'fromStore')(modelName, query, options);
+}

package/addon/decorators/is-equal.js

@@ -0,0 +1,15 @@
+import { computed } from '@ember/object';
+import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
+import { assert } from '@ember/debug';
+
+export function isEqual(propNameA, propNameB) {
+    return decoratorWithRequiredParams(function (target, desc, key, params) {
+        assert(`The @isEqual decorator requires two property names as parameters`, params.length === 2);
+
+        let [a, b] = params;
+
+        return computed(a, b, function () {
+            return this.get(a) === this.get(b);
+        });
+    }, 'isEqual')(propNameA, propNameB);
+}

package/addon/exports/host-services.js

@@ -0,0 +1,18 @@
+const hostServices = [
+    'store',
+    'session',
+    'current-user',
+    'fetch',
+    'media',
+    'app-cache',
+    'url-search-params',
+    'modals-manager',
+    'loader',
+    'filters',
+    'crud',
+    'notifications',
+    'fileQueue',
+    { hostRouter: 'router' },
+];
+
+export default hostServices;

package/addon/exports/services.js

@@ -0,0 +1,18 @@
+const services = [
+    'store',
+    'session',
+    'current-user',
+    'fetch',
+    'media',
+    'app-cache',
+    'url-search-params',
+    'modals-manager',
+    'loader',
+    'filters',
+    'crud',
+    'notifications',
+    'hostRouter',
+    'fileQueue',
+];
+
+export default services;

package/addon/initializers/local-storage-adapter.js

@@ -0,0 +1,21 @@
+import Store from '@ember-data/store';
+import { importData, exportData } from 'ember-local-storage/helpers/import-export';
+
+export function initialize() {
+    if (!Store.prototype._emberLocalStoragePatched) {
+        Store.reopen({
+            _emberLocalStoragePatched: true,
+            importData: function (json, options) {
+                return importData(this, json, options);
+            },
+            exportData: function (types, options) {
+                return exportData(this, types, options);
+            },
+        });
+    }
+}
+
+export default {
+    name: 'local-storage-adapter',
+    initialize: initialize,
+};

package/addon/serializers/application.js

@@ -0,0 +1,87 @@
+import RESTSerializer from '@ember-data/serializer/rest';
+import { isNone } from '@ember/utils';
+import { underscore } from '@ember/string';
+import { isArray } from '@ember/array';
+import normalizePolymorphicTypeWithinHash from '../utils/serialize/normalize-polymorphic-type-within-hash';
+
+export default class ApplicationSerializer extends RESTSerializer {
+    /**
+     * Default primary keys to uuid
+     *
+     * @var {string}
+     */
+    primaryKey = 'uuid';
+
+    /**
+     * keyForPolymorphicType can be used to define a custom key when serializing and deserializing a polymorphic type.
+     * By default, the returned key is ${key}Type.
+     *
+     * @var {String}
+     */
+    keyForPolymorphicType(key, typeClass, method) {
+        return `${underscore(key)}_type`;
+    }
+
+    /**
+     * Customize serializer so that any attributes that are instances of Models or objects
+     * that are to accept and ID get serialized into the id only
+     *
+     * @param {Snapshot} snapshot
+     * @param {Object} options
+     * @return {Object} json
+     */
+    serialize(snapshot) {
+        const json = super.serialize(...arguments);
+
+        // for each relationship make sure the id is set
+        snapshot.eachRelationship((key, relationship) => {
+            const { kind } = relationship.meta;
+
+            if (kind === 'belongsTo') {
+                const relationSnapshot = snapshot.belongsTo(key);
+
+                key = this.keyForRelationship ? this.keyForRelationship(key, 'belongsTo', 'serialize') : key;
+
+                if (isNone(relationSnapshot)) {
+                    return;
+                }
+
+                json[`${key}_uuid`] = relationSnapshot.id;
+            }
+        });
+
+        return json;
+    }
+
+    /**
+     * Normalizes a part of the JSON payload returned by the server.
+     *
+     * @method normalize
+     * @param {Model} modelClass
+     * @param {Object} resourceHash
+     * @param {String} prop
+     * @return {Object}
+     */
+    normalize(model, hash, prop) {
+        hash = normalizePolymorphicTypeWithinHash(hash);
+
+        return super.normalize(model, hash, prop);
+    }
+
+    /**
+     * We only want to save dirty/changed model attributes
+     *
+     * @param {Snapshot} snapshot
+     * @param {Object} json
+     * @param {String} key
+     * @param {Array} attributes
+     */
+    serializeAttribute(snapshot, json, key, attributes) {
+        const { modelName } = snapshot;
+        const excludedKeys = ['name', 'meta', 'options', 'config', 'excluded_addons', 'translations', 'tags'];
+
+        if (snapshot.record?.get('isNew') || snapshot.changedAttributes()[key] || isArray(snapshot.attr(key)) || excludedKeys.includes(key)) {
+            return super.serializeAttribute(snapshot, json, key, attributes);
+        }
+    }
+}

package/addon/services/app-cache.js

@@ -0,0 +1,59 @@
+import Service from '@ember/service';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { isArray } from '@ember/array';
+import { dasherize } from '@ember/string';
+import { storageFor } from 'ember-local-storage';
+import autoSerialize from '../utils/auto-serialize';
+
+export default class AppCacheService extends Service {
+    @service currentUser;
+    @service store;
+    @storageFor('local-cache') localCache;
+
+    get cachePrefix() {
+        return `${this.currentUser.id}:${this.currentUser.companyId}:`;
+    }
+
+    @action setEmberData(key, value, except = []) {
+        value = autoSerialize(value, except);
+
+        return this.set(key, value);
+    }
+
+    @action getEmberData(key, modelName) {
+        const data = this.get(key);
+
+        if (isArray(data)) {
+            return data.map((instance) => this.store.push(this.store.normalize(modelName, instance)));
+        }
+
+        return this.store.push(this.store.normalize(modelName, data));
+    }
+
+    @action set(key, value) {
+        this.localCache.set(`${this.cachePrefix}${dasherize(key)}`, value);
+
+        return this;
+    }
+
+    @action get(key) {
+        return this.localCache.get(`${this.cachePrefix}${dasherize(key)}`);
+    }
+
+    @action has(key) {
+        if (isArray(key)) {
+            return key.every((k) => this.get(k) !== undefined);
+        }
+
+        return this.get(key) !== undefined;
+    }
+
+    @action doesntHave(key) {
+        if (isArray(key)) {
+            return key.every((k) => this.get(k) === undefined);
+        }
+
+        return this.get(key) === undefined;
+    }
+}