@fleetbase/ember-core 0.2.13 → 0.2.14

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/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;
@@ -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/decorators/engine-service.js

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

package/app/utils/is-string.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fleetbase/ember-core",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
   "keywords": [
     "fleetbase-core",