renamed modules to loaders

Author: Umed Khudoiberdiev

README.md

@@ -1,22 +1,24 @@
 # Microframework
 
-Microframework is a simple tool that allows you to execute your modules in a proper order, 
+Microframework is a simple tool that allows you to execute and configure your modules (called *loaders*) in a proper order, 
 helping you to organize bootstrap code in your application.
 
 ## Usage
 
-First, install the module:
+First, install microframework:
 
 ```
 npm i microframework
 ```
 
-Second, create a simple "module" named `expressModule`:
+Second, create a simple "loader" named `expressLoader`. 
+Loader is a place where you can configure all your modules during microframework bootstrap.
+All loaders are executed one by one in a sequential order.
 
 ```typescript
 import {MicroframeworkSettings} from "microframework";
 
-export function expressModule(settings: MicroframeworkSettings) {
+export function expressLoader(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();
@@ -28,69 +30,70 @@ export function expressModule(settings: MicroframeworkSettings) {
     // run application to listen on given port
     app.listen(3000);
 
-    // your module also can return a promise
+    // your loader also can return a promise and microframework will wait for it in a proper order
 }
 ```
 
-Create `app.ts` and bootstrap a microframework and your express module:
+Create `app.ts` and bootstrap a microframework and your express loader:
 
 ```typescript
 import {bootstrapMicroframework} from "microframework";
-import {expressModule} from "./expressModule";
+import {expressLoader} from "./expressLoader";
 
 bootstrapMicroframework([
-    expressModule
+    expressLoader
 ])
     .then(() => console.log("Application is up and running."))
     .catch(error => console.log("Application is crashed: " + error));
 ```
 
-That's all. You can do same for other modules. 
-Take a look on sample to understand better how concept of modules and their bootstrapping in microframework.
+That's all. You can do same for other loaders. 
+Take a look on sample to understand better how concept of loaders and their bootstrapping in microframework.
 
 ## Settings
 
 You can specify additional options to microframework.
 
-* `logo` - Logo needs to be used before application launches. To use logo ansi-art module should be installed.
-* `showBootstrapTime` - If set to true then framework shows how much time was spend to bootstrap all modules.
-* `bootstrapTimeout` - Number of milliseconds to wait before framework will bootstrap all modules.
+* `logo` - Logo needs to be used before application launches. To use logo ansi-art node module should be installed.
+* `showBootstrapTime` - If set to true then framework shows how much time was spend to bootstrap microframework.
+* `bootstrapTimeout` - Number of milliseconds to wait before framework will bootstrap.
 
 Example of using settings:
 
 ```typescript
 import {bootstrapMicroframework} from "microframework";
+import {expressLoader} from "./expressLoader";
 
 bootstrapMicroframework({
     config: {
         logo: "MyApp",
         showBootstrapTime: true,
         bootstrapTimeout: 10
     }, 
-    modules: [
-        expressModule,
+    loaders: [
+        expressLoader,
         // ...
     ]
 })
     .then(() => console.log("Application is up and running."))
     .catch(error => console.log("Application is crashed: " + error));
 ```
 
-## Sharing data across modules
+## Sharing data across loaders
 
-Sometimes few modules need to communicate between each other and use shared data.
-For such purpose you can store the data in `settings` object passed to each module
-and use stored data across all other modules. For example:
+Sometimes few loaders need to communicate between each other and use shared data.
+For such purpose you can store the data in `settings` object passed to each loader
+and use stored data across all other loaders. For example:
 
 ```typescript
 import {MicroframeworkSettings} from "microframework";
 
-export function expressModule(settings: MicroframeworkSettings) {
+export function expressLoader(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();
 
-    // register all routes, Routes are just routes that should be stored outside of this module
+    // register all routes, Routes are just routes that should be stored outside of this loader
     const routes: any = Routes;
     Object.keys(routes).forEach(routePath => app.get(routePath, routes[routePath]));
 
@@ -101,12 +104,12 @@ export function expressModule(settings: MicroframeworkSettings) {
 }
 ```
 
-And another modules can use data this way:
+And another loaders can use data this way:
 
 ```typescript
 import {MicroframeworkSettings} from "microframework";
 
-export function socketIoModule(settings: MicroframeworkSettings) {
+export function socketIoLoader(settings: MicroframeworkSettings) {
     const io = io();
     io.useExpress(settings.getData("express_app"));
 }
@@ -118,15 +121,16 @@ In the case if you want to shutdown running application you need to do following
 
 ```typescript
 import {bootstrapMicroframework} from "microframework";
+import {expressLoader} from "./expressLoader";
 
 bootstrapMicroframework({
     config: {
         logo: "MyApp",
         showBootstrapTime: true,
         bootstrapTimeout: 10
     }, 
-    modules: [
-        expressModule,
+    loaders: [
+        expressLoader,
         // ...
     ]
 })
@@ -142,7 +146,7 @@ bootstrapMicroframework({
     .catch(error => console.log("Application is crashed: " + error));
 ```
 
-All modules which use resources should release them, for example:
+All loaders which use resources should release them, for example:
 
 ```typescript
 export async function typeormModule(settings: MicroframeworkSettings) {
@@ -156,6 +160,6 @@ export async function typeormModule(settings: MicroframeworkSettings) {
         }
     });
 
-    settings.onShutdown(() => connection.close());
+    settings.onShutdown(() => connection.close()); // closing connection on microframework shutdown
 }
 ```

package.json

@@ -1,7 +1,7 @@
 {
   "name": "microframework",
   "private": true,
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Microframework is a minimalistic framework you can use with TypeScript and JavaScript.",
   "license": "MIT",
   "readmeFilename": "README.md",

sample/app.ts

@@ -1,17 +1,17 @@
 import {bootstrapMicroframework} from "../src/index";
-import {expressModule} from "./modules/expressModule";
-import {typeormModule} from "./modules/typeormModule";
-import {winstonModule} from "./modules/winstonModule";
+import {expressLoader} from "./modules/expressLoader";
+import {typeormLoader} from "./modules/typeormLoader";
+import {winstonLoader} from "./modules/winstonLoader";
 
 bootstrapMicroframework({
     config: { // completely optional
         logo: "MyAwesomeApp", // completely optional, to use this setting you'll need to install ascii-art module
         showBootstrapTime: true, // completely optional
     },
-    modules: [
-        expressModule,
-        winstonModule,
-        typeormModule, // comment this module if you don't have database to setup connection with
+    loaders: [
+        expressLoader,
+        winstonLoader,
+        typeormLoader, // comment this module if you don't have database to setup connection with
 
         // here we can setup other databases, any other lib we want to setup in our application
     ]

sample/modules/expressModule.ts renamed to sample/modules/expressLoader.ts

@@ -2,7 +2,7 @@ import * as express from "express";
 import {MicroframeworkSettings} from "../../src/MicroframeworkSettings";
 import {Routes} from "../controllers/controllers";
 
-export function expressModule(settings: MicroframeworkSettings) {
+export function expressLoader(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();
@@ -14,6 +14,6 @@ export function expressModule(settings: MicroframeworkSettings) {
     // run application to listen on given port
     app.listen(3000);
 
-    // here we can set the data for other modules
+    // here we can set the data for other loaders
     settings.setData("express_app", app);
 }

sample/modules/typeormModule.ts renamed to sample/modules/typeormLoader.ts

@@ -1,7 +1,7 @@
 import {createConnection} from "typeorm";
 import {MicroframeworkSettings} from "../../src/MicroframeworkSettings";
 
-export async function typeormModule(settings: MicroframeworkSettings) {
+export async function typeormLoader(settings: MicroframeworkSettings) {
     const connection = await createConnection({
         driver: {
             type: "mysql",

sample/modules/winstonModule.ts renamed to sample/modules/winstonLoader.ts

@@ -1,7 +1,7 @@
 import {MicroframeworkSettings} from "../../src/MicroframeworkSettings";
 const winston = require("winston");
 
-export function winstonModule(settings: MicroframeworkSettings) {
+export function winstonLoader(settings: MicroframeworkSettings) {
     winston.configure({
         transports: [
             new winston.transports.File({

src/Microframework.ts

@@ -1,5 +1,5 @@
 import {MicroframeworkSettings} from "./MicroframeworkSettings";
-import {MicroframeworkModule} from "./MicroframeworkModule";
+import {MicroframeworkLoader} from "./MicroframeworkLoader";
 import {MicroframeworkConfig} from "./MicroframeworkConfig";
 import {MicroframeworkNotBootstrappedError} from "./error/MicroframeworkNotBootstrappedError";
 import {MicroframeworkAsciiArtNotInstalledError} from "./error/MicroframeworkAsciiArtNotInstalledError";
@@ -19,12 +19,12 @@ export class Microframework {
     private frameworkConfig?: MicroframeworkConfig;
 
     /**
-     * Stores all registered microframework modules.
+     * Stores all registered microframework loaders.
      */
-    private modules: MicroframeworkModule[] = [];
+    private loaders: MicroframeworkLoader[] = [];
 
     /**
-     * Stores all settings of modules bootstrapped by microframework.
+     * Stores all settings of loaders bootstrapped by microframework.
      * If its undefined it means framework is not bootstrapped yet.
      */
     private frameworkSettings?: MicroframeworkSettings;
@@ -42,39 +42,39 @@ export class Microframework {
     }
 
     /**
-     * Registers module in the framework.
+     * Registers loader in the framework.
      */
-    registerModule(module: MicroframeworkModule): this {
-        this.modules.push(module);
+    registerLoader(loader: MicroframeworkLoader): this {
+        this.loaders.push(loader);
         return this;
     }
 
     /**
-     * Registers modules in the framework.
+     * Registers loaders in the framework.
      */
-    registerModules(modules: MicroframeworkModule[]): this;
+    registerLoaders(loaders: MicroframeworkLoader[]): this;
 
     /**
-     * Registers modules in the framework.
+     * Registers loaders in the framework.
      */
-    registerModules(...modules: MicroframeworkModule[]): this;
+    registerLoaders(...loaders: MicroframeworkLoader[]): this;
 
     /**
-     * Registers modules in the framework.
+     * Registers loaders in the framework.
      */
-    registerModules(modules: any /* MicroframeworkModule[]|MicroframeworkModule[][] */): this {
-        ((modules as any[]) || []).forEach(module => {
-            if (module instanceof Array) {
-                this.modules.push(...module);
+    registerLoaders(loaders: any /* MicroframeworkModule[]|MicroframeworkModule[][] */): this {
+        ((loaders as any[]) || []).forEach(loader => {
+            if (loader instanceof Array) {
+                this.loaders.push(...loader);
             } else {
-                this.modules.push(module);
+                this.loaders.push(loader);
             }
         });
         return this;
     }
 
     /**
-     * Bootstraps all modules.
+     * Bootstraps microframework and loads all loaders.
      */
     bootstrap(): Promise<this> {
         const settings = new MicroframeworkSettings();
@@ -86,9 +86,9 @@ export class Microframework {
                 return this.createBootstrapTimeout();
 
             }).then(() => {
-                return this.runInSequence(this.modules, module => {
-                    const moduleResult = module(settings);
-                    return moduleResult instanceof Promise ? moduleResult : Promise.resolve();
+                return this.runInSequence(this.loaders, loader => {
+                    const loaderResult = loader(settings);
+                    return loaderResult instanceof Promise ? loaderResult : Promise.resolve();
                 });
 
             }).then(() => {
@@ -100,7 +100,7 @@ export class Microframework {
     }
 
     /**
-     * Shutdowns all modules.
+     * Shutdowns microframework and everything loaders registered for shutdown.
      */
     shutdown(): Promise<this> {
         if (!this.frameworkSettings)
@@ -113,7 +113,7 @@ export class Microframework {
     }
 
     /**
-     * Returns microframework settings used and modified by bootstrapped modules.
+     * Returns microframework settings used and modified by bootstrapped loaders.
      * If framework was not bootstrapped yet, this accessor will throw an error.
      */
     get settings(): MicroframeworkSettings {

src/MicroframeworkBootstrapConfig.ts

@@ -1,5 +1,5 @@
 import {MicroframeworkConfig} from "./MicroframeworkConfig";
-import {MicroframeworkModule} from "./MicroframeworkModule";
+import {MicroframeworkLoader} from "./MicroframeworkLoader";
 
 /**
  * Microframework bootstrap configuration.
@@ -8,12 +8,14 @@ export interface MicroframeworkBootstrapConfig {
 
     /**
      * Microframework configuration.
+     * Can be file name, or array of file names from where to read configuration.
+     * File should be relative to package.json of the project (project root).
      */
-    config?: MicroframeworkConfig;
+    config?: MicroframeworkConfig|string|string[];
 
     /**
-     * Modules needs to be registered in microframework.
+     * Loaders to be registered in microframework and executed on microframework bootstrap.
      */
-    modules?: MicroframeworkModule[];
+    loaders?: MicroframeworkLoader[];
 
 }

src/MicroframeworkModule.ts renamed to src/MicroframeworkLoader.ts

@@ -1,8 +1,8 @@
 import {MicroframeworkSettings} from "./MicroframeworkSettings";
 
 /**
- * Microframework module is some functionality needs to be executed in order.
+ * Microframework loader is a function that executes in order on microframework bootstrap.
  */
-export interface MicroframeworkModule {
+export interface MicroframeworkLoader {
     (options?: MicroframeworkSettings): Promise<any>|any;
 }

src/MicroframeworkSettings.ts

@@ -1,7 +1,7 @@
 import {ShutdownHandler} from "./ShutdownHandler";
 
 /**
- * Bootstrap settings used across all modules.
+ * Bootstrap settings used across all loader.
  * Used to register shutdown handlers - special functions that will be executed when framework is shutdown.
  * Also can be used to store and share data across modules.
  */