Merge pull request #34 from kitesjs/dev-studio

Dev react studio

Author: vunb

app.ts

@@ -0,0 +1,9 @@
+import { engine } from '@kites/core';
+
+async function bootstrap() {
+  // load config & autodiscover
+  const app = await engine(true).init();
+  app.logger.info('Kites application started!');
+}
+
+bootstrap();

gulpfile.js

@@ -11,6 +11,7 @@ const packages = {
   core: ts.createProject('packages/core/tsconfig.json'),
   express: ts.createProject('packages/express/tsconfig.json'),
   rest: ts.createProject('packages/rest/tsconfig.json'),
+  react: ts.createProject('packages/react/tsconfig.json'),
 };
 const modules = Object.keys(packages);
 const source = 'packages';
@@ -37,6 +38,7 @@ gulp.task('copy-misc', function () {
     .pipe(gulp.dest(`${source}/core`))
     .pipe(gulp.dest(`${source}/express`))
     .pipe(gulp.dest(`${source}/rest`))
+    .pipe(gulp.dest(`${source}/react`))
 });
 
 gulp.task('clean:output', function () {

kites.config.json

@@ -6,7 +6,6 @@
       "transport": "console",
       "level": "debug"
     }
-
   },
   "extensions": null
 }

package.json

@@ -10,7 +10,7 @@
     "format": "prettier **/**/*.ts --ignore-path ./.prettierignore --write && git status",
     "tsc": "tsc",
     "start": "npm run start:dev",
-    "start:dev": "npm run todo",
+    "start:dev": "ts-node app.ts",
     "todo": "ts-node sample/01-todo-app/app.ts",
     "test": "mocha \"./packages/**/*.spec.ts\" --reporter spec --retries 3 --require ts-node/register --require node_modules/reflect-metadata/Reflect.js --exit",
     "clean": "gulp clean:bundle",

packages/core/engine/kites-factory.ts

@@ -11,6 +11,7 @@ export const KITES_INSTANCE = new InjectionToken('KITES_INSTANCE');
 export function engine(options?: IKitesOptions | boolean) {
   if (typeof options === 'boolean') {
     options = {
+      loadConfig: options,
       discover: options
     };
   }

packages/core/engine/kites-instance.spec.ts

@@ -38,18 +38,14 @@ describe('kites engine', () => {
   });
 
   it('should use a legal extension', async () => {
-    class Aa implements KitesExtension {
-      get name() {
-        return 'abc';
-      }
 
-      init(core: IKites) {
-        core.logger.info('Kites extension initializing ...');
-        expect(core.isInitialized).eq(false, 'The application should not be ready!');
+    const app = await engine().use({
+      name: 'test',
+      main: function (kites: KitesInstance, definition: KitesExtension) {
+        kites.logger.info('Kites extension initializing ...');
+        expect(kites.isInitialized).eq(false, 'The application should not be ready!');
       }
-    }
-
-    const app = await engine().use(new Aa()).init();
+    }).init();
     expect(app.isInitialized).eq(true, 'The application should be ready!');
     expect(app).instanceOf(KitesInstance);
   });

packages/core/engine/kites-instance.ts

@@ -105,6 +105,7 @@ export class KitesInstance extends EventEmitter implements IKites {
     const parent = module.parent || module;
     const defaultLevel = process.env.NODE_ENV === 'production' ? 'info' : 'debug';
     return {
+      loadConfig: false,
       appDirectory: appRoot.toString(),
       // TODO: separate kites discover as an api
       // EXAMPLE 1: kites.discover(true)
@@ -240,10 +241,10 @@ export class KitesInstance extends EventEmitter implements IKites {
     await this.extensionsManager.init();
     await this.initializeListeners.fire();
 
+    this.initialized = true;
     this.logger.info('kites initialized!');
-    this.emit('ready', this);
 
-    this.initialized = true;
+    this.emit('ready', this);
     return this;
   }
 

packages/core/extensions/discover.spec.ts

@@ -9,7 +9,7 @@ describe('Discover extensions', () => {
     const logger = getDebugLogger('kites:discover');
     let extensions: any = await discover({
       logger,
-      rootDirectory: [location]
+      directories: [location]
     });
     logger.info('Discovery location: ' + location);
     expect(extensions.length).eq(1);

packages/core/extensions/discover.ts

@@ -17,7 +17,7 @@ export type DiscoverOptions = string | boolean | [boolean, number, ...string[]];
 export interface IDiscoverOptions {
   readonly logger: Logger;
   readonly depth?: number;
-  readonly rootDirectory: string[];
+  readonly directories: string[];
   readonly env?: any;
   readonly cacheAvailableExtensions?: any;
   readonly tempDirectory?: any;
@@ -33,20 +33,23 @@ var availableExtensionsCache: any;
  */
 export async function discover(config: IDiscoverOptions) {
 
-  config.logger.info('Searching for available extensions in ' + config.rootDirectory);
+  config.logger.info('Searching for available extensions in ' + config.directories);
 
   if (config.cacheAvailableExtensions && availableExtensionsCache != null) {
     config.logger.info(`Loading extensions from cache: count(${availableExtensionsCache.length})`);
     return Promise.resolve(availableExtensionsCache);
   } else {
+    let availableExtensions = [];
     let results = await cache.get(config);
+
     config.logger.info(`Found: ${results.length} extensions!`);
-    let availableExtensions = results.map((configFile) => {
-      let extension = require(configFile);
-      return _.extend({
-        directory: path.dirname(configFile)
-      }, extension);
-    });
+    for (const configFile of results) {
+      let extension = await import(configFile);
+      availableExtensions.push({
+        directory: path.dirname(configFile),
+        ...extension,
+      });
+    }
 
     availableExtensionsCache = availableExtensions;
     await cache.save(availableExtensions, config);

packages/core/extensions/extensions-manager.ts

@@ -54,11 +54,13 @@ class ExtensionsManager extends EventEmitter {
     if (typeof this.kites.options.discover === 'undefined') {
       this.kites.options.discover = [false, 0];
     } else if (typeof this.kites.options.discover === 'boolean') {
-      this.kites.options.discover = [this.kites.options.discover, 2, this.kites.options.appDirectory];
+      this.kites.options.discover = [this.kites.options.discover, 3, this.kites.options.appDirectory];
     } else if (typeof this.kites.options.discover === 'string') {
-      this.kites.options.discover = [true, 2, this.kites.options.discover];
+      this.kites.options.discover = [true, 3, this.kites.options.discover];
     } else if (this.kites.options.discover.length < 2) {
       throw new Error('Discover options as array requires at least 2 elements! Example: [true, 2]');
+    } else if (this.kites.options.discover.length < 3) {
+      this.kites.options.discover.push(this.kites.options.appDirectory);
     }
 
     // autodiscover extensions
@@ -73,7 +75,7 @@ class ExtensionsManager extends EventEmitter {
         logger: this.kites.logger,
         env: this.kites.options.env,
         depth: depth,
-        rootDirectory: directories,
+        directories: directories,
         tempDirectory: this.kites.options.tempDirectory,
       });
       this.kites.logger.debug('Autodiscover ' + extensions.length + ' extensions!');
@@ -96,69 +98,70 @@ class ExtensionsManager extends EventEmitter {
    * Execute init extensions
    * @param extensions
    */
-  private useMany(extensions: KitesExtension[]) {
-    var promises = extensions.map((e) => this.useOne(e));
-    return Promise.all(promises);
+  private async useMany(extensions: KitesExtension[]) {
+    for (const e of extensions) {
+      await this.useOne(e);
+    }
   }
 
   /**
    * Execute init one extension
    * @param extension
    */
-  private useOne(extension: KitesExtension) {
-    // extends options
-    // Review _.assign(), _.defaults(), or _.merge?
-    const xname = extension.name && extension.name.toLowerCase();
-    const options = _.assign<
-      ExtensionOptions,
-      ExtensionOptions | undefined,
-      ExtensionOptions | undefined>({}, extension.options, this.kites.options[xname]);
-
-    extension.options = options;
-    this.kites.options[xname] = options;
-
-    if (options.enabled === false) {
-      this.kites.logger.debug(`Extension ${extension.name} is disabled, skipping`);
-      return Promise.resolve();
-    }
+  private async useOne(extension: KitesExtension) {
+    try {
 
-    return Promise.resolve()
-      .then(() => {
-        if (typeof extension.main === 'function') {
-          (extension.main as Function).call(this, this.kites, extension);
-          return Promise.resolve();
-        } else if (typeof extension.main === 'string' && extension.directory) {
-          // TODO: REMOVE, reason: Un-Support
-          let extPath = path.join(extension.directory, extension.main);
-          let extModule = require(extPath);
-          extModule.call(this, this.kites, extension);
-          return Promise.resolve();
-        } else if (typeof extension.init === 'function') {
-          (extension.init as Function).call(this, this.kites, extension);
-          return Promise.resolve();
-        } else {
-          return Promise.reject('Invalid kites extension: ' + extension.name);
-        }
-      })
-      .then(() => {
-        if (options.enabled !== false) {
-          this.emit('extension:registered', extension);
-        } else {
-          this.kites.logger.debug(`Extension ${extension.name} was disabled`);
-        }
-      })
-      .catch((e: Error) => {
-        let errorMsg;
+      // extends options
+      // Review _.assign(), _.defaults(), or _.merge?
+      const xname = extension.name && extension.name.toLowerCase();
+      const options = _.assign<
+        ExtensionOptions,
+        ExtensionOptions | undefined,
+        ExtensionOptions | undefined>({}, extension.options, this.kites.options[xname]);
+
+      extension.options = options;
+      this.kites.options[xname] = options;
 
+      if (options.enabled === false) {
         if (!extension.name) {
-          errorMsg = `Error when loading anonymous extension ${extension.directory != null ? ` at ${extension.directory}` : ''}${os.EOL}${e.stack}`;
+          this.kites.logger.debug(`Anonymous Extension${extension.directory != null ? ` at ${extension.directory}` : ''} is disabled, skipping`);
         } else {
-          errorMsg = `Error when loading extension ${extension.name}${os.EOL}${e.stack}`;
+          this.kites.logger.debug(`Extension ${extension.name} is disabled, skipping`);
         }
-
-        this.kites.logger.error(errorMsg);
-        throw new Error(errorMsg);
-      });
+        return;
+      }
+
+      if (!extension.name) {
+        this.kites.logger.info(`Register extension: anonymous${extension.directory != null ? ` at ${extension.directory}` : ''}`);
+      } else {
+        this.kites.logger.info(`Register extension: ${extension.name}`);
+      }
+
+      if (typeof extension.main === 'function') {
+        // execute main function without await!
+        (extension.main as Function).call(this, this.kites, extension);
+      } else if (typeof extension.main === 'string' && extension.directory) {
+        const main = await import(path.join(extension.directory, extension.main));
+        // ES6 Module support
+        // execute main function without await!
+        (main && main.default).call(this, this.kites, extension);
+      } else {
+        throw new Error('Invalid kites extension: ' + extension.name + ' -> ' + JSON.stringify(extension));
+      }
+
+      this.emit('extension:registered', extension);
+    } catch (error) {
+      let errorMsg;
+
+      if (!extension.name) {
+        errorMsg = `Error when loading anonymous extension ${extension.directory != null ? ` at ${extension.directory}` : ''}${os.EOL}${error.stack}`;
+      } else {
+        errorMsg = `Error when loading extension ${extension.name}${os.EOL}${error.stack}`;
+      }
+
+      this.kites.logger.error(errorMsg);
+      throw new Error(errorMsg);
+    }
   }
 
 }