@fleetbase/ember-core 0.2.13 → 0.2.15

package/addon/abilities/dynamic.js

@@ -0,0 +1,39 @@
+import { Ability } from 'ember-can';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { singularize } from 'ember-inflector';
+
+export default class extends Ability {
+    @service currentUser;
+    @tracked service;
+    @tracked resource;
+    @tracked ability;
+    @tracked permissions = new Set();
+
+    constructor() {
+        super(...arguments);
+        this.permissions = new Set(this.currentUser.permissions.map((permission) => permission.name));
+    }
+
+    parseProperty(str) {
+        let [service, ability, resource] = str.split(' ');
+
+        this.service = service;
+        this.ability = ability;
+        this.resource = singularize(resource);
+
+        return 'can';
+    }
+
+    get can() {
+        if (this.currentUser.isAdmin) {
+            return true;
+        }
+
+        const permission = [this.service, this.ability, this.resource].join(' ');
+        const wilcardPermission = [this.service, '*', this.resource].join(' ');
+        const wildcardServicePermission = [this.service, '*'].join(' ');
+
+        return this.permissions.has(permission) || this.permissions.has(wilcardPermission) || this.permissions.has(wildcardServicePermission);
+    }
+}

package/addon/decorators/engine-service.js

@@ -0,0 +1,25 @@
+import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
+import { computed } from '@ember/object';
+import { assert } from '@ember/debug';
+import injectEngineService from '../utils/inject-engine-service';
+import isObject from '../utils/is-object';
+
+export default decoratorWithRequiredParams(function (target, key, descriptor, [engineName, options = {}]) {
+    assert('The first argument of the @engineService decorator must be a string', typeof engineName === 'string');
+    assert('The second argument of the @engineService decorator must be an object', isObject(options));
+
+    const { initializer } = descriptor;
+    delete descriptor.initializer;
+
+    const cp = computed(`_engineService_${key}`, function () {
+        const service = injectEngineService(this, engineName, key, options);
+
+        if (initializer) {
+            return initializer.call(this);
+        }
+
+        return service;
+    });
+
+    return cp(target, key, descriptor);
+});

package/addon/decorators/fetch-from.js

@@ -1,55 +1,52 @@
 import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
-import { assert } from '@ember/debug';
 import { getOwner } from '@ember/application';
-import { scheduleOnce } from '@ember/runloop';
+import { assert } from '@ember/debug';
 
-export default function fetchFrom(endpoint, query = {}, options = {}) {
+export default decoratorWithRequiredParams(function (target, key, descriptor, [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) {
-        const symbol = Symbol(`__${key}_fetchFrom`);
+    // Remove value and writable if previously set, use getter instead
+    delete descriptor.value;
+    delete descriptor.writable;
+    delete descriptor.initializer;
+
+    // Create symbol to track value
+    const symbol = Symbol(`__${key}_fetchFrom`);
+
+    // Setter to get symbol value
+    descriptor.set = function (value) {
+        this[symbol] = value;
+    };
+
+    // Get or set symbol value
+    descriptor.get = async function () {
+        if (this[symbol] !== undefined) {
+            return this[symbol];
+        }
 
-        Object.defineProperty(target, symbol, {
+        Object.defineProperty(this, 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, []);
-                    });
+        const owner = getOwner(this);
+        const fetch = owner.lookup('service:fetch');
+        return fetch
+            .get(endpoint, query, options)
+            .then((response) => {
+                this.set(key, response);
+                if (options && typeof options.onComplete === 'function') {
+                    options.onComplete(response, this);
+                }
+            })
+            .catch(() => {
+                this.set(key, null);
             });
-        };
-    }, 'fetchFrom')(endpoint, query, options);
-}
+    };
+
+    return descriptor;
+});

package/addon/decorators/from-store.js

@@ -1,55 +1,52 @@
 import { decoratorWithRequiredParams } from '@ember-decorators/utils/decorator';
-import { assert } from '@ember/debug';
 import { getOwner } from '@ember/application';
-import { scheduleOnce } from '@ember/runloop';
+import { assert } from '@ember/debug';
+
+export default decoratorWithRequiredParams(function (target, key, descriptor, [modelName, query = {}, options = {}]) {
+    assert('The first argument of the @fetchFrom decorator must be a string', typeof modelName === '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');
+
+    // Remove value and writable if previously set, use getter instead
+    delete descriptor.value;
+    delete descriptor.writable;
+    delete descriptor.initializer;
+
+    // Create symbol to track value
+    const symbol = Symbol(`__${key}_fromStore`);
 
-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');
+    // Setter to get symbol value
+    descriptor.set = function (value) {
+        this[symbol] = value;
+    };
 
-    return decoratorWithRequiredParams(function (target, key) {
-        const symbol = Symbol(`__${key}_fromStore`);
+    // Get or set symbol value
+    descriptor.get = function () {
+        if (this[symbol] !== undefined) {
+            return this[symbol];
+        }
 
-        Object.defineProperty(target, symbol, {
+        Object.defineProperty(this, 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, []);
-                    });
+        const owner = getOwner(this);
+        const store = owner.lookup('service:store');
+        return store
+            .query(modelName, query, options)
+            .then((response) => {
+                this.set(key, response);
+                if (options && typeof options.onComplete === 'function') {
+                    options.onComplete(response, this);
+                }
+            })
+            .catch(() => {
+                this.set(key, null);
             });
-        };
-    }, 'fromStore')(modelName, query, options);
-}
+    };
+
+    return descriptor;
+});

package/addon/exports/host-services.js

@@ -15,6 +15,7 @@ const hostServices = [
     'fileQueue',
     'universe',
     'intl',
+    'abilities',
     { hostRouter: 'router' },
 ];
 

package/addon/exports/services.js

@@ -16,6 +16,7 @@ const services = [
     'fileQueue',
     'universe',
     'intl',
+    'abilities',
 ];
 
 export default services;

package/addon/services/abilities.js

@@ -0,0 +1,7 @@
+import Service from 'ember-can/services/abilities';
+
+export default class AbilitiesService extends Service {
+    parse(propertyName) {
+        return { propertyName, abilityName: 'dynamic' };
+    }
+}

package/addon/services/current-user.js

@@ -54,6 +54,13 @@ export default class CurrentUserService extends Service.extend(Evented) {
         id: 'anon',
     };
 
+    /**
+     * The current users permissions.
+     *
+     * @memberof CurrentUserService
+     */
+    @tracked permissions = [];
+
     /**
      * User options in localStorage
      *
@@ -96,36 +103,82 @@ export default class CurrentUserService extends Service.extend(Evented) {
      */
     @alias('user.company_uuid') companyId;
 
+    /**
+     * Alias for if user is admin.
+     *
+     * @var {Boolean}
+     * @memberof CurrentUserService
+     */
+    @alias('user.is_admin') isAdmin;
+
+    /**
+     * The prefix for this user options
+     *
+     * @var {String}
+     */
+    @computed('id') get optionsPrefix() {
+        return `${this.id}:`;
+    }
+
+    get latitude() {
+        return this.whois('latitude');
+    }
+
+    get longitude() {
+        return this.whois('longitude');
+    }
+
+    get currency() {
+        return this.whois('currency.code');
+    }
+
+    get city() {
+        return this.whois('city');
+    }
+
+    get country() {
+        return this.whois('country_code');
+    }
+
     /**
      * Loads the current authenticated user
      *
-     * @void
+     * @return Promise<UserModel>|null
      */
     async load() {
         if (this.session.isAuthenticated) {
             let user = await this.store.findRecord('user', 'me');
             this.set('user', user);
             this.trigger('user.loaded', user);
+
+            // Set permissions
+            this.permissions = this.getUserPermissions(user);
+
+            return user;
         }
+
+        return null;
     }
 
     /**
      * Resolves a user model.
      *
-     * @return {Promise}
+     * @return {Promise<User>}
      */
     @action promiseUser(options = {}) {
         const NoUserAuthenticatedError = new Error('Failed to authenticate user.');
 
         return new Promise((resolve, reject) => {
             if (this.session.isAuthenticated) {
-                return this.store
-                    .queryRecord('user', { me: true })
-                    .then((user) => {
+                try {
+                    this.store.queryRecord('user', { me: true }).then((user) => {
                         // set the `current user`
                         this.set('user', user);
                         this.trigger('user.loaded', user);
 
+                        // Set permissions
+                        this.permissions = this.getUserPermissions(user);
+
                         // set environment from user option
                         this.theme.setEnvironment();
 
@@ -135,10 +188,10 @@ export default class CurrentUserService extends Service.extend(Evented) {
                         }
 
                         resolve(user);
-                    })
-                    .catch(() => {
-                        reject(NoUserAuthenticatedError);
                     });
+                } catch (error) {
+                    reject(NoUserAuthenticatedError);
+                }
             } else {
                 reject(NoUserAuthenticatedError);
             }
@@ -146,60 +199,56 @@ export default class CurrentUserService extends Service.extend(Evented) {
     }
 
     /**
-     * Loads and resolved all current users installed order configurations.
+     * Gets all user permissions.
      *
-     * @return {Promise}
+     * @param {UserModel} user
+     * @return {Array}
+     * @memberof CurrentUserService
      */
-    @action getInstalledOrderConfigs(params = {}) {
-        return new Promise((resolve, reject) => {
-            this.fetch
-                .get('fleet-ops/order-configs/get-installed', params)
-                .then((configs) => {
-                    const serialized = [];
+    getUserPermissions(user) {
+        const permissions = [];
 
-                    for (let i = 0; i < configs.length; i++) {
-                        const config = configs.objectAt(i);
-                        const normalizedConfig = this.store.normalize('order-config', config);
-                        const serializedConfig = this.store.push(normalizedConfig);
+        // get direct applied permissions
+        if (user.get('permissions')) {
+            permissions.pushObjects(user.get('permissions').toArray());
+        }
+
+        // get role permissions and role policies permissions
+        if (user.get('role')) {
+            if (user.get('role.permissions')) {
+                permissions.pushObjects(user.get('role.permissions').toArray());
+            }
 
-                        serialized.pushObject(serializedConfig);
+            if (user.get('role.policies')) {
+                for (let i = 0; i < user.get('role.policies').length; i++) {
+                    const policy = user.get('role.policies').objectAt(i);
+                    if (policy.get('permissions')) {
+                        permissions.pushObjects(policy.get('permissions').toArray());
                     }
+                }
+            }
+        }
 
-                    resolve(serialized);
-                })
-                .catch(reject);
-        });
+        // get direct applied policy permissions
+        if (user.get('policies')) {
+            for (let i = 0; i < user.get('policies').length; i++) {
+                const policy = user.get('policies').objectAt(i);
+                if (policy.get('permissions')) {
+                    permissions.pushObjects(policy.get('permissions').toArray());
+                }
+            }
+        }
+
+        return permissions;
     }
 
     /**
-     * The prefix for this user options
+     * Alias to get a user's whois property
      *
-     * @var {String}
+     * @param {String} key
+     * @return {Mixed}
+     * @memberof CurrentUserService
      */
-    @computed('id') get optionsPrefix() {
-        return `${this.id}:`;
-    }
-
-    get latitude() {
-        return this.whois('latitude');
-    }
-
-    get longitude() {
-        return this.whois('longitude');
-    }
-
-    get currency() {
-        return this.whois('currency.code');
-    }
-
-    get city() {
-        return this.whois('city');
-    }
-
-    get country() {
-        return this.whois('country_code');
-    }
-
     @action whois(key) {
         return this.getWhoisProperty(key);
     }

package/addon/services/universe.js

@@ -13,6 +13,7 @@ import RSVP from 'rsvp';
 import loadInstalledExtensions from '../utils/load-installed-extensions';
 import loadExtensions from '../utils/load-extensions';
 import getWithDefault from '../utils/get-with-default';
+import config from 'ember-get-config';
 
 export default class UniverseService extends Service.extend(Evented) {
     @service router;
@@ -846,7 +847,7 @@ export default class UniverseService extends Service.extend(Evented) {
         // If component is a definition register to host application
         if (typeof component === 'function') {
             const owner = getOwner(this);
-            const widgetId = component.widgetId || widgetId || this._createUniqueWidgetHashFromDefinition(component);
+            widgetId = component.widgetId || widgetId || this._createUniqueWidgetHashFromDefinition(component);
 
             if (owner) {
                 owner.register(`component:${widgetId}`, component);
@@ -1058,29 +1059,88 @@ export default class UniverseService extends Service.extend(Evented) {
     }
 
     /**
-     * Manually registers a component in a specified engine.
+     * Registers a component class under one or more names within a specified engine instance.
+     * This function provides flexibility in component registration by supporting registration under the component's
+     * full class name, a simplified alias derived from the class name, and an optional custom name provided through the options.
+     * This flexibility facilitates varied referencing styles within different parts of the application, enhancing modularity and reuse.
      *
-     * @method registerComponentInEngine
-     * @public
-     * @memberof UniverseService
-     * @param {String} engineName - The name of the engine where the component should be registered.
-     * @param {Object} componentClass - The component class to register, which should have a 'name' property.
+     * @param {string} engineName - The name of the engine where the component will be registered.
+     * @param {class} componentClass - The component class to be registered. Must be a class, not an instance.
+     * @param {Object} [options] - Optional parameters for additional configuration.
+     * @param {string} [options.registerAs] - A custom name under which the component can also be registered.
+     *
+     * @example
+     * // Register a component with its default and alias names
+     * registerComponentInEngine('mainEngine', HeaderComponent);
+     *
+     * // Additionally register the component under a custom name
+     * registerComponentInEngine('mainEngine', HeaderComponent, { registerAs: 'header' });
+     *
+     * @remarks
+     * - The function does not return any value.
+     * - Registration only occurs if:
+     *   - The specified engine instance exists.
+     *   - The component class is properly defined with a non-empty name.
+     *   - The custom name, if provided, must be a valid string.
+     *   - Allows flexible component referencing by registering under multiple names.
      */
-    registerComponentInEngine(engineName, componentClass) {
+    registerComponentInEngine(engineName, componentClass, options = {}) {
         const engineInstance = this.getEngineInstance(engineName);
-        if (engineInstance && !isBlank(componentClass) && typeof componentClass.name === 'string') {
+        this.registerComponentToEngineInstance(engineInstance, componentClass, options);
+    }
+
+    /**
+     * Registers a component class under its full class name, a simplified alias, and an optional custom name within a specific engine instance.
+     * This helper function does the actual registration of the component to the engine instance. It registers the component under its
+     * full class name, a dasherized alias of the class name (with 'Component' suffix removed if present), and any custom name provided via options.
+     *
+     * @param {EngineInstance} engineInstance - The engine instance where the component will be registered.
+     * @param {class} componentClass - The component class to be registered. This should be a class reference, not an instance.
+     * @param {Object} [options] - Optional parameters for further configuration.
+     * @param {string} [options.registerAs] - A custom name under which the component can be registered.
+     *
+     * @example
+     * // Typical usage within the system (not usually called directly by users)
+     * registerComponentToEngineInstance(engineInstance, HeaderComponent, { registerAs: 'header' });
+     *
+     * @remarks
+     * - No return value.
+     * - The registration is performed only if:
+     *   - The engine instance is valid and not null.
+     *   - The component class has a defined and non-empty name.
+     *   - The custom name, if provided, is a valid string.
+     * - This function directly manipulates the engine instance's registration map.
+     */
+    registerComponentToEngineInstance(engineInstance, componentClass, options = {}) {
+        if (engineInstance && componentClass && typeof componentClass.name === 'string') {
             engineInstance.register(`component:${componentClass.name}`, componentClass);
+            engineInstance.register(`component:${dasherize(componentClass.name.replace('Component', ''))}`, componentClass);
+            if (options && typeof options.registerAs === 'string') {
+                engineInstance.register(`component:${options.registerAs}`, componentClass);
+            }
         }
     }
 
     /**
-     * Manually registers a service in a specified engine.
+     * Registers a service from one engine instance to another within the application.
+     * This method retrieves an instance of a service from the current engine and then registers it
+     * in a target engine, allowing the service to be shared across different parts of the application.
      *
-     * @method registerComponentInEngine
-     * @public
-     * @memberof UniverseService
-     * @param {String} engineName - The name of the engine where the component should be registered.
-     * @param {Object} serviceClass - The service class to register, which should have a 'name' property.
+     * @param {string} targetEngineName - The name of the engine where the service should be registered.
+     * @param {string} serviceName - The name of the service to be shared and registered.
+     * @param {Object} currentEngineInstance - The engine instance that currently holds the service to be shared.
+     *
+     * @example
+     * // Assuming 'appEngine' and 'componentEngine' are existing engine instances and 'logger' is a service in 'appEngine'
+     * registerServiceInEngine('componentEngine', 'logger', appEngine);
+     *
+     * Note:
+     * - This function does not return any value.
+     * - It only performs registration if all provided parameters are valid:
+     *   - Both engine instances must exist.
+     *   - The service name must be a string.
+     *   - The service must exist in the current engine instance.
+     *   - The service is registered without instantiating a new copy in the target engine.
      */
     registerServiceInEngine(targetEngineName, serviceName, currentEngineInstance) {
         // Get the target engine instance
@@ -1111,11 +1171,16 @@ export default class UniverseService extends Service.extend(Evented) {
      *   userService.doSomething();
      * }
      */
-    getServiceFromEngine(engineName, serviceName) {
+    getServiceFromEngine(engineName, serviceName, options = {}) {
         const engineInstance = this.getEngineInstance(engineName);
 
         if (engineInstance && typeof serviceName === 'string') {
             const serviceInstance = engineInstance.lookup(`service:${serviceName}`);
+            if (options && options.inject) {
+                for (let injectionName in options.inject) {
+                    serviceInstance[injectionName] = options.inject[injectionName];
+                }
+            }
             return serviceInstance;
         }
 
@@ -1287,6 +1352,7 @@ export default class UniverseService extends Service.extend(Evented) {
     bootEngines(owner = null) {
         const booted = [];
         const pending = [];
+        const additionalCoreExtensions = config.APP.extensions ?? [];
 
         // If no owner provided use the owner of this service
         if (owner === null) {
@@ -1296,9 +1362,11 @@ export default class UniverseService extends Service.extend(Evented) {
         const tryBootEngine = (extension) => {
             this.loadEngine(extension.name).then((engineInstance) => {
                 if (engineInstance.base && engineInstance.base.setupExtension) {
-                    const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
+                    if (booted.includes(extension.name)) {
+                        return;
+                    }
 
-                    // Check if all dependency engines are booted
+                    const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
                     const allDependenciesBooted = engineDependencies.every((dep) => booted.includes(dep));
 
                     if (!allDependenciesBooted) {
@@ -1320,6 +1388,10 @@ export default class UniverseService extends Service.extend(Evented) {
             const stillPending = [];
 
             pending.forEach(({ extension, engineInstance }) => {
+                if (booted.includes(extension.name)) {
+                    return;
+                }
+
                 const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
                 const allDependenciesBooted = engineDependencies.every((dep) => booted.includes(dep));
 
@@ -1333,13 +1405,13 @@ export default class UniverseService extends Service.extend(Evented) {
             });
 
             // If no progress was made, log an error in debug/development mode
-            assert('Some engines have unmet dependencies and cannot be booted:', pending.length === stillPending.length);
+            assert(`Some engines have unmet dependencies and cannot be booted:`, stillPending.length === 0 && pending.length === 0);
 
             pending.length = 0;
             pending.push(...stillPending);
         };
 
-        loadInstalledExtensions().then((extensions) => {
+        loadInstalledExtensions(additionalCoreExtensions).then((extensions) => {
             extensions.forEach((extension) => {
                 tryBootEngine(extension);
             });

package/addon/utils/inject-engine-service.js

@@ -1,10 +1,49 @@
 import { getOwner } from '@ember/application';
+import { isArray } from '@ember/array';
+import isObject from './is-object';
 
-export default function injectEngineService(target, engineName, serviceName, key = null) {
+function findService(owner, target, serviceName) {
+    let service = target[serviceName];
+    if (!service) {
+        service = owner.lookup(`service:${serviceName}`);
+    }
+
+    return service;
+}
+
+function injectServices(service, target, owner, injections) {
+    if (isArray(injections)) {
+        for (let i = 0; i < injections.length; i++) {
+            const serviceName = injections[i];
+            service[serviceName] = findService(owner, target, serviceName);
+        }
+    } else if (isObject(injections)) {
+        for (let serviceName in injections) {
+            service[serviceName] = injections[serviceName] ?? findService(owner, target, serviceName);
+        }
+    }
+}
+
+// unresolved services value will be the key as a string
+function automaticServiceResolution(service, target, owner) {
+    for (let prop in service) {
+        if (typeof prop === 'string' && typeof service[prop] === 'string' && prop === service[prop]) {
+            service[prop] = findService(owner, target, prop);
+        }
+    }
+}
+
+export default function injectEngineService(target, engineName, serviceName, options = {}) {
     const owner = getOwner(target);
     const universe = owner.lookup('service:universe');
     const service = universe.getServiceFromEngine(engineName, serviceName);
+    const key = options.key || null;
     const effectiveServiceName = key || serviceName;
+    if (options && options.inject) {
+        injectServices(service, target, owner, options.inject);
+    } else {
+        automaticServiceResolution(service, target, owner);
+    }
 
     Object.defineProperty(target, effectiveServiceName, {
         value: service,
@@ -12,4 +51,6 @@ export default function injectEngineService(target, engineName, serviceName, key
         configurable: true,
         enumerable: true,
     });
+
+    return service;
 }

package/addon/utils/is-string.js

@@ -0,0 +1,3 @@
+export default function isString(_var) {
+    return typeof _var === 'string';
+}

package/addon/utils/load-installed-extensions.js

@@ -1,8 +1,15 @@
 import loadExtensions from '../utils/load-extensions';
 import fleetbaseApiFetch from '../utils/fleetbase-api-fetch';
 
-export default async function loadInstalledExtensions() {
-    const CORE_ENGINES = ['@fleetbase/fleetops-engine', '@fleetbase/storefront-engine', '@fleetbase/registry-bridge-engine', '@fleetbase/dev-engine', '@fleetbase/iam-engine'];
+export default async function loadInstalledExtensions(additionalCoreEngines = []) {
+    const CORE_ENGINES = [
+        '@fleetbase/fleetops-engine',
+        '@fleetbase/storefront-engine',
+        '@fleetbase/registry-bridge-engine',
+        '@fleetbase/dev-engine',
+        '@fleetbase/iam-engine',
+        ...additionalCoreEngines,
+    ];
     const INDEXED_ENGINES = await loadExtensions();
     const INSTALLED_ENGINES = await fleetbaseApiFetch('get', 'engines', {}, { namespace: '~registry/v1', fallbackResponse: [] });
 

package/app/abilities/dynamic.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/abilities/dynamic';

package/app/decorators/engine-service.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/decorators/engine-service';

package/app/services/abilities.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/services/abilities';

package/app/utils/is-string.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/is-string';

package/index.js

@@ -41,6 +41,7 @@ module.exports = {
             new Funnel(path.dirname(require.resolve('socketcluster-client')), {
                 files: ['socketcluster-client.min.js'],
                 destDir: '/assets',
+                allowEmpty: true,
             })
         );
 

package/package.json

@@ -1,128 +1,126 @@
 {
-  "name": "@fleetbase/ember-core",
-  "version": "0.2.13",
-  "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
-  "keywords": [
-    "fleetbase-core",
-    "fleetbase-services",
-    "fleetbase",
-    "ember-addon"
-  ],
-  "repository": "https://github.com/fleetbase/ember-core",
-  "license": "AGPL-3.0-or-later",
-  "author": "Fleetbase Pte Ltd <hello@fleetbase.io>",
-  "directories": {
-    "app": "app",
-    "addon": "addon",
-    "tests": "tests"
-  },
-  "scripts": {
-    "build": "ember build --environment=production",
-    "lint": "concurrently \"npm:lint:*(!fix)\" --names \"lint:\"",
-    "lint:css": "stylelint \"**/*.css\"",
-    "lint:css:fix": "concurrently \"npm:lint:css -- --fix\"",
-    "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
-    "lint:hbs": "ember-template-lint .",
-    "lint:hbs:fix": "ember-template-lint . --fix",
-    "lint:js": "eslint . --cache",
-    "lint:js:fix": "eslint . --fix",
-    "start": "ember serve",
-    "test": "concurrently \"npm:lint\" \"npm:test:*\" --names \"lint,test:\"",
-    "test:ember": "ember test",
-    "test:ember-compatibility": "ember try:each",
-    "publish:npm": "npm config set registry https://registry.npmjs.org/ && npm publish",
-    "publish:github": "npm config set '@fleetbase:registry' https://npm.pkg.github.com/ && npm publish"
-  },
-  "dependencies": {
-    "@babel/core": "^7.23.2",
-    "compress-json": "^3.0.0",
-    "date-fns": "^2.30.0",
-    "ember-auto-import": "^2.6.3",
-    "ember-cli-babel": "^8.2.0",
-    "ember-cli-htmlbars": "^6.3.0",
-    "ember-cli-notifications": "^9.0.0",
-    "ember-concurrency": "^3.1.1",
-    "ember-concurrency-decorators": "^2.0.3",
-    "ember-decorators": "^6.1.1",
-    "ember-get-config": "^2.1.1",
-    "ember-inflector": "^4.0.2",
-    "ember-intl": "6.3.2",
-    "ember-loading": "^2.0.0",
-    "ember-local-storage": "^2.0.4",
-    "ember-simple-auth": "^6.0.0",
-    "ember-wormhole": "^0.6.0",
-    "socketcluster-client": "^17.1.1"
-  },
-  "devDependencies": {
-    "@babel/eslint-parser": "^7.22.15",
-    "@babel/plugin-proposal-decorators": "^7.23.2",
-    "@ember/optional-features": "^2.0.0",
-    "@ember/test-helpers": "^3.2.0",
-    "@embroider/test-setup": "^3.0.2",
-    "@glimmer/component": "^1.1.2",
-    "@glimmer/tracking": "^1.1.2",
-    "broccoli-asset-rev": "^3.0.0",
-    "broccoli-funnel": "^3.0.8",
-    "broccoli-merge-trees": "^4.2.0",
-    "broccoli-persistent-filter": "^3.1.3",
-    "concurrently": "^8.2.2",
-    "ember-cli": "~5.4.1",
-    "ember-cli-clean-css": "^3.0.0",
-    "ember-cli-dependency-checker": "^3.3.2",
-    "ember-cli-inject-live-reload": "^2.1.0",
-    "ember-cli-sri": "^2.1.1",
-    "ember-cli-terser": "^4.0.2",
-    "ember-data": "^4.12.5",
-    "ember-file-upload": "8.4.0",
-    "ember-load-initializers": "^2.1.2",
-    "ember-page-title": "^8.0.0",
-    "ember-qunit": "^8.0.1",
-    "ember-resolver": "^11.0.1",
-    "ember-source": "~5.4.0",
-    "ember-source-channel-url": "^3.0.0",
-    "ember-template-lint": "^5.11.2",
-    "ember-try": "^3.0.0",
-    "eslint": "^8.52.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-ember": "^11.11.1",
-    "eslint-plugin-n": "^16.2.0",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-qunit": "^8.0.1",
-    "loader.js": "^4.7.0",
-    "prettier": "^3.0.3",
-    "qunit": "^2.20.0",
-    "qunit-dom": "^2.0.0",
-    "resolve": "^1.22.2",
-    "stylelint": "^15.11.0",
-    "stylelint-config-standard": "^34.0.0",
-    "stylelint-prettier": "^4.0.2",
-    "webpack": "^5.89.0"
-  },
-  "overrides": {
-    "broccoli-persistent-filter": "^3.1.3"
-  },
-  "engines": {
-    "node": ">= 18"
-  },
-  "ember": {
-    "edition": "octane"
-  },
-  "ember-addon": {
-    "configPath": "tests/dummy/config"
-  },
-  "prettier": {
-    "trailingComma": "es5",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true,
-    "printWidth": 190,
-    "overrides": [
-      {
-        "files": "*.hbs",
-        "options": {
-          "singleQuote": false
-        }
-      }
-    ]
-  }
+    "name": "@fleetbase/ember-core",
+    "version": "0.2.15",
+    "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
+    "keywords": [
+        "fleetbase-core",
+        "fleetbase-services",
+        "fleetbase",
+        "ember-addon"
+    ],
+    "repository": "https://github.com/fleetbase/ember-core",
+    "license": "AGPL-3.0-or-later",
+    "author": "Fleetbase Pte Ltd <hello@fleetbase.io>",
+    "directories": {
+        "app": "app",
+        "addon": "addon",
+        "tests": "tests"
+    },
+    "scripts": {
+        "build": "ember build --environment=production",
+        "lint": "concurrently \"npm:lint:*(!fix)\" --names \"lint:\"",
+        "lint:css": "stylelint \"**/*.css\"",
+        "lint:css:fix": "concurrently \"npm:lint:css -- --fix\"",
+        "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
+        "lint:hbs": "ember-template-lint .",
+        "lint:hbs:fix": "ember-template-lint . --fix",
+        "lint:js": "eslint . --cache",
+        "lint:js:fix": "eslint . --fix",
+        "start": "ember serve",
+        "test": "concurrently \"npm:lint\" \"npm:test:*\" --names \"lint,test:\"",
+        "test:ember": "ember test",
+        "test:ember-compatibility": "ember try:each",
+        "publish:npm": "npm config set registry https://registry.npmjs.org/ && npm publish",
+        "publish:github": "npm config set '@fleetbase:registry' https://npm.pkg.github.com/ && npm publish"
+    },
+    "dependencies": {
+        "@babel/core": "^7.23.2",
+        "compress-json": "^3.0.0",
+        "date-fns": "^2.30.0",
+        "ember-auto-import": "^2.7.4",
+        "ember-can": "^6.0.0",
+        "ember-cli-babel": "^8.2.0",
+        "ember-cli-htmlbars": "^6.3.0",
+        "ember-cli-notifications": "^9.0.0",
+        "ember-concurrency": "^3.1.1",
+        "ember-concurrency-decorators": "^2.0.3",
+        "ember-decorators": "^6.1.1",
+        "ember-get-config": "^2.1.1",
+        "ember-inflector": "^4.0.2",
+        "ember-intl": "6.3.2",
+        "ember-loading": "^2.0.0",
+        "ember-local-storage": "^2.0.4",
+        "ember-simple-auth": "^6.0.0",
+        "ember-wormhole": "^0.6.0",
+        "socketcluster-client": "^17.1.1"
+    },
+    "devDependencies": {
+        "@babel/eslint-parser": "^7.22.15",
+        "@babel/plugin-proposal-decorators": "^7.23.2",
+        "@ember/optional-features": "^2.0.0",
+        "@ember/test-helpers": "^3.2.0",
+        "@embroider/test-setup": "^3.0.2",
+        "@glimmer/component": "^1.1.2",
+        "@glimmer/tracking": "^1.1.2",
+        "broccoli-asset-rev": "^3.0.0",
+        "broccoli-funnel": "^3.0.8",
+        "broccoli-merge-trees": "^4.2.0",
+        "broccoli-persistent-filter": "^3.1.3",
+        "concurrently": "^8.2.2",
+        "ember-cli": "~5.4.1",
+        "ember-cli-clean-css": "^3.0.0",
+        "ember-cli-dependency-checker": "^3.3.2",
+        "ember-cli-inject-live-reload": "^2.1.0",
+        "ember-cli-sri": "^2.1.1",
+        "ember-cli-terser": "^4.0.2",
+        "ember-data": "^4.12.5",
+        "ember-file-upload": "8.4.0",
+        "ember-load-initializers": "^2.1.2",
+        "ember-page-title": "^8.0.0",
+        "ember-qunit": "^8.0.1",
+        "ember-resolver": "^11.0.1",
+        "ember-source": "~5.4.0",
+        "ember-source-channel-url": "^3.0.0",
+        "ember-template-lint": "^5.11.2",
+        "ember-try": "^3.0.0",
+        "eslint": "^8.52.0",
+        "eslint-config-prettier": "^9.0.0",
+        "eslint-plugin-ember": "^11.11.1",
+        "eslint-plugin-n": "^16.2.0",
+        "eslint-plugin-prettier": "^5.0.1",
+        "eslint-plugin-qunit": "^8.0.1",
+        "loader.js": "^4.7.0",
+        "prettier": "^3.0.3",
+        "qunit": "^2.20.0",
+        "qunit-dom": "^2.0.0",
+        "resolve": "^1.22.2",
+        "stylelint": "^15.11.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-prettier": "^4.0.2",
+        "webpack": "^5.89.0"
+    },
+    "engines": {
+        "node": ">= 18"
+    },
+    "ember": {
+        "edition": "octane"
+    },
+    "ember-addon": {
+        "configPath": "tests/dummy/config"
+    },
+    "prettier": {
+        "trailingComma": "es5",
+        "tabWidth": 4,
+        "semi": true,
+        "singleQuote": true,
+        "printWidth": 190,
+        "overrides": [
+            {
+                "files": "*.hbs",
+                "options": {
+                    "singleQuote": false
+                }
+            }
+        ]
+    }
 }