@fleetbase/ember-core 0.2.12 → 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

@@ -8,8 +8,12 @@ import { A, isArray } from '@ember/array';
 import { later } from '@ember/runloop';
 import { dasherize, camelize } from '@ember/string';
 import { getOwner } from '@ember/application';
-import { assert } from '@ember/debug';
+import { assert, debug } from '@ember/debug';
 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;
@@ -1055,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
@@ -1108,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;
         }
 
@@ -1269,6 +1337,162 @@ export default class UniverseService extends Service.extend(Evented) {
         return null;
     }
 
+    /**
+     * Boot all installed engines, ensuring dependencies are resolved.
+     *
+     * This method attempts to boot all installed engines by first checking if all
+     * their dependencies are already booted. If an engine has dependencies that
+     * are not yet booted, it is deferred and retried after its dependencies are
+     * booted. If some dependencies are never booted, an error is logged.
+     *
+     * @method bootEngines
+     * @param {ApplicationInstance|null} owner - The Ember ApplicationInstance that owns the engines.
+     * @return {void}
+     */
+    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) {
+            owner = getOwner(this);
+        }
+
+        const tryBootEngine = (extension) => {
+            this.loadEngine(extension.name).then((engineInstance) => {
+                if (engineInstance.base && engineInstance.base.setupExtension) {
+                    if (booted.includes(extension.name)) {
+                        return;
+                    }
+
+                    const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
+                    const allDependenciesBooted = engineDependencies.every((dep) => booted.includes(dep));
+
+                    if (!allDependenciesBooted) {
+                        pending.push({ extension, engineInstance });
+                        return;
+                    }
+
+                    engineInstance.base.setupExtension(owner, engineInstance, this);
+                    booted.push(extension.name);
+                    debug(`Booted : ${extension.name}`);
+
+                    // Try booting pending engines again
+                    tryBootPendingEngines();
+                }
+            });
+        };
+
+        const tryBootPendingEngines = () => {
+            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));
+
+                if (allDependenciesBooted) {
+                    engineInstance.base.setupExtension(owner, engineInstance, this);
+                    booted.push(extension.name);
+                    debug(`Booted : ${extension.name}`);
+                } else {
+                    stillPending.push({ extension, engineInstance });
+                }
+            });
+
+            // If no progress was made, log an error in debug/development mode
+            assert(`Some engines have unmet dependencies and cannot be booted:`, stillPending.length === 0 && pending.length === 0);
+
+            pending.length = 0;
+            pending.push(...stillPending);
+        };
+
+        loadInstalledExtensions(additionalCoreExtensions).then((extensions) => {
+            extensions.forEach((extension) => {
+                tryBootEngine(extension);
+            });
+        });
+    }
+
+    /**
+     * Boots all installed engines, ensuring dependencies are resolved.
+     *
+     * This method loads all installed extensions and then attempts to boot each engine.
+     * For each extension, it loads the engine and, if the engine has a `setupExtension`
+     * method in its base, it calls this method to complete the setup. This function ensures
+     * that dependencies are resolved before booting the engines. If some dependencies are
+     * never booted, an error is logged.
+     *
+     * @method legacyBootEngines
+     * @param {ApplicationInstance|null} owner - The Ember ApplicationInstance that owns the engines.
+     * @return {void}
+     */
+    legacyBootEngines(owner = null) {
+        const booted = [];
+        const pending = [];
+
+        // If no owner provided use the owner of this service
+        if (owner === null) {
+            owner = getOwner(this);
+        }
+
+        const tryBootEngine = (extension) => {
+            this.loadEngine(extension.name).then((engineInstance) => {
+                if (engineInstance.base && engineInstance.base.setupExtension) {
+                    const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
+
+                    // Check if all dependency engines are booted
+                    const allDependenciesBooted = engineDependencies.every((dep) => booted.includes(dep));
+
+                    if (!allDependenciesBooted) {
+                        pending.push({ extension, engineInstance });
+                        return;
+                    }
+
+                    engineInstance.base.setupExtension(owner, engineInstance, this);
+                    booted.push(extension.name);
+                    debug(`Booted : ${extension.name}`);
+
+                    // Try booting pending engines again
+                    tryBootPendingEngines();
+                }
+            });
+        };
+
+        const tryBootPendingEngines = () => {
+            const stillPending = [];
+
+            pending.forEach(({ extension, engineInstance }) => {
+                const engineDependencies = getWithDefault(engineInstance.base, 'engineDependencies', []);
+                const allDependenciesBooted = engineDependencies.every((dep) => booted.includes(dep));
+
+                if (allDependenciesBooted) {
+                    engineInstance.base.setupExtension(owner, engineInstance, this);
+                    booted.push(extension.name);
+                    debug(`Booted : ${extension.name}`);
+                } else {
+                    stillPending.push({ extension, engineInstance });
+                }
+            });
+
+            // 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);
+
+            pending.length = 0;
+            pending.push(...stillPending);
+        };
+
+        loadExtensions().then((extensions) => {
+            extensions.forEach((extension) => {
+                tryBootEngine(extension);
+            });
+        });
+    }
+
     /**
      * Alias for intl service `t`
      *

package/addon/utils/fleetbase-api-fetch.js

@@ -0,0 +1,63 @@
+import config from 'ember-get-config';
+
+export default async function fleetbaseApiFetch(method, uri, params = {}, fetchOptions = {}) {
+    // Prepare base URL
+    const baseUrl = `${config.API.host}/${fetchOptions.namespace ?? config.API.namespace}`;
+
+    // Initialize headers
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+
+    // Check localStorage for the session data
+    const localStorageSession = JSON.parse(window.localStorage.getItem('ember_simple_auth-session'));
+    let token;
+    if (localStorageSession) {
+        const { authenticated } = localStorageSession;
+        if (authenticated) {
+            token = authenticated.token;
+        }
+    }
+
+    // Set Authorization header if token is available
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    // Configure request options
+    const options = {
+        method,
+        headers,
+    };
+
+    // Handle params based on method
+    if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method) && params) {
+        options.body = JSON.stringify(params);
+    } else if (method === 'GET' && params) {
+        // Add params to URL for GET requests
+        const urlParams = new URLSearchParams(params).toString();
+        uri += `?${urlParams}`;
+    }
+
+    try {
+        // Make the fetch request
+        const response = await fetch(`${baseUrl}/${uri}`, options);
+
+        // Check if the response is OK (status in the range 200-299)
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+
+        // Parse and return the JSON response
+        return await response.json();
+    } catch (error) {
+        // If a fallback response is provided use it instead
+        if (fetchOptions && fetchOptions.fallbackResponse !== undefined) {
+            return fetchOptions.fallbackResponse;
+        }
+
+        // Handle errors (network errors, JSON parsing errors, etc.)
+        console.error('Error making request:', error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,23 @@
+import loadExtensions from '../utils/load-extensions';
+import fleetbaseApiFetch from '../utils/fleetbase-api-fetch';
+
+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: [] });
+
+    const isInstalledEngine = (engineName) => {
+        return CORE_ENGINES.includes(engineName) || INSTALLED_ENGINES.find((pkg) => pkg.name === engineName);
+    };
+
+    return INDEXED_ENGINES.filter((pkg) => {
+        return isInstalledEngine(pkg.name);
+    });
+}

package/app/decorators/engine-service.js

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

package/app/utils/fleetbase-api-fetch.js

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

package/app/utils/is-string.js

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

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

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/load-installed-extensions';

package/package.json

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