renamed bootstrap settings to simply settings

Author: Umed Khudoiberdiev

README.md

@@ -14,9 +14,9 @@ npm i microframework
 Second, create a simple "module" named `expressModule`:
 
 ```typescript
-import {MicroframeworkBootstrapSettings} from "microframework";
+import {MicroframeworkSettings} from "microframework";
 
-export function expressModule(settings: MicroframeworkBootstrapSettings) {
+export function expressModule(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();
@@ -83,9 +83,9 @@ For such purpose you can store the data in `settings` object passed to each modu
 and use stored data across all other modules. For example:
 
 ```typescript
-import {MicroframeworkBootstrapSettings} from "microframework";
+import {MicroframeworkSettings} from "microframework";
 
-export function expressModule(settings: MicroframeworkBootstrapSettings) {
+export function expressModule(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();
@@ -104,9 +104,9 @@ export function expressModule(settings: MicroframeworkBootstrapSettings) {
 And another modules can use data this way:
 
 ```typescript
-import {MicroframeworkBootstrapSettings} from "microframework";
+import {MicroframeworkSettings} from "microframework";
 
-export function socketIoModule(settings: MicroframeworkBootstrapSettings) {
+export function socketIoModule(settings: MicroframeworkSettings) {
     const io = io();
     io.useExpress(settings.getData("express_app"));
 }
@@ -145,7 +145,7 @@ bootstrapMicroframework({
 All modules which use resources should release them, for example:
 
 ```typescript
-export async function typeormModule(settings: MicroframeworkBootstrapSettings) {
+export async function typeormModule(settings: MicroframeworkSettings) {
     const connection = await createConnection({
         driver: {
             type: "mysql",
@@ -156,6 +156,6 @@ export async function typeormModule(settings: MicroframeworkBootstrapSettings) {
         }
     });
 
-    settings.addShutdownHandler(() => connection.close());
+    settings.onShutdown(() => connection.close());
 }
 ```

package.json

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

sample/app.ts

@@ -1,7 +1,7 @@
 import {bootstrapMicroframework} from "../src/index";
-import {expressModule} from "./framework/expressModule";
-import {typeormModule} from "./framework/typeormModule";
-import {winstonModule} from "./framework/winstonModule";
+import {expressModule} from "./modules/expressModule";
+import {typeormModule} from "./modules/typeormModule";
+import {winstonModule} from "./modules/winstonModule";
 
 bootstrapMicroframework({
     config: { // completely optional

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

@@ -1,8 +1,8 @@
 import * as express from "express";
-import {MicroframeworkBootstrapSettings} from "../../src/MicroframeworkBootstrapSettings";
+import {MicroframeworkSettings} from "../../src/MicroframeworkSettings";
 import {Routes} from "../controllers/controllers";
 
-export function expressModule(settings: MicroframeworkBootstrapSettings) {
+export function expressModule(settings: MicroframeworkSettings) {
 
     // create express app
     const app = express();

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

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

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

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

src/Microframework.ts

@@ -1,4 +1,4 @@
-import {MicroframeworkBootstrapSettings} from "./MicroframeworkBootstrapSettings";
+import {MicroframeworkSettings} from "./MicroframeworkSettings";
 import {MicroframeworkModule} from "./MicroframeworkModule";
 import {MicroframeworkConfig} from "./MicroframeworkConfig";
 import {MicroframeworkNotBootstrappedError} from "./error/MicroframeworkNotBootstrappedError";
@@ -27,7 +27,7 @@ export class Microframework {
      * Stores all settings of modules bootstrapped by microframework.
      * If its undefined it means framework is not bootstrapped yet.
      */
-    private settings?: MicroframeworkBootstrapSettings;
+    private settings?: MicroframeworkSettings;
 
     // -------------------------------------------------------------------------
     // Public Methods
@@ -77,7 +77,7 @@ export class Microframework {
      * Bootstraps all modules.
      */
     bootstrap(): Promise<this> {
-        const settings = new MicroframeworkBootstrapSettings();
+        const settings = new MicroframeworkSettings();
         const bootstrapTime = +new Date();
 
         return this.generateLogo()

src/MicroframeworkConfig.ts

@@ -6,6 +6,8 @@ export interface MicroframeworkConfig {
     /**
      * Logo needs to be used before application launches.
      * To use logo ansi-art module should be installed.
+     *
+     * @experimental
      */
     logo?: string;
 

src/MicroframeworkModule.ts

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

src/MicroframeworkBootstrapSettings.ts renamed to src/MicroframeworkSettings.ts

@@ -1,11 +1,11 @@
-import {MicroframeworkShutdownHandler} from "./MicroframeworkShutdownHandler";
+import {ShutdownHandler} from "./ShutdownHandler";
 
 /**
  * Bootstrap settings used across all modules.
  * 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.
  */
-export class MicroframeworkBootstrapSettings {
+export class MicroframeworkSettings {
 
     // -------------------------------------------------------------------------
     // Private Properties
@@ -19,7 +19,7 @@ export class MicroframeworkBootstrapSettings {
     /**
      * Special functions that will be executed when framework is shutdown.
      */
-    private shutdownHandlers: MicroframeworkShutdownHandler[] = [];
+    private shutdownHandlers: ShutdownHandler[] = [];
 
     // -------------------------------------------------------------------------
     // Public Methods
@@ -43,15 +43,15 @@ export class MicroframeworkBootstrapSettings {
     /**
      * Adds a shutdown handler - special function that will be executed when framework is shutdown.
      */
-    addShutdownHandler(handler: MicroframeworkShutdownHandler): this {
+    onShutdown(handler: ShutdownHandler): this {
         this.shutdownHandlers.push(handler);
         return this;
     }
 
     /**
      * Gets all shutdown handlers - special functions that will be executed when framework is shutdown.
      */
-    getShutdownHandlers(): MicroframeworkShutdownHandler[] {
+    getShutdownHandlers(): ShutdownHandler[] {
         return this.shutdownHandlers.map(handlers => handlers);
     }