A core Pluggable framework based on koa.

Don't use it directly, see egg.

Directory structure

├── package.json
├── app.js (optional)
├── agent.js (optional)
├── app
|   ├── router.js
│   ├── controller
│   │   └── home.js
|   ├── extend (optional)
│   |   ├── helper.js (optional)
│   |   ├── filter.js (optional)
│   |   ├── request.js (optional)
│   |   ├── response.js (optional)
│   |   ├── context.js (optional)
│   |   ├── application.js (optional)
│   |   └── agent.js (optional)
│   ├── service (optional)
│   ├── middleware (optional)
│   │   └── response_time.js
│   └── view (optional)
|       ├── layout.html
│       └── home.html
├── config
|   ├── config.default.js
│   ├── config.prod.js
|   ├── config.test.js (optional)
|   ├── config.local.js (optional)
|   ├── config.unittest.js (optional)
│   └── plugin.js

Then you can start with code below

const Application = require('egg-core').EggCore;
const app = new Application({
  baseDir: '/path/to/app'
});
app.ready(() => app.listen(3000));

EggLoader can easily load files or directories in your egg project. In addition, you can customize the loader with low level APIs.

• {String} baseDir - current directory of application
• {Object} app - instance of egg application
• {Object} plugins - merge plugins for test
• {Logger} logger - logger instance，default is console

Load config/plugin.js

Load config/config.js and config/{serverEnv}.js

Load app/controller

Load app/middleware

Load app/extend/application.js

Load app/extend/context.js

Load app/extend/request.js

Load app/extend/response.js

Load app/extend/helper.js

Load app.js

Load agent.js

Load app/service

Retrieve application environment variable values via serverEnv. You can access directly by calling this.serverEnv after instantiation.

To get directories of the frameworks. A new framework is created by extending egg, then you can use this function to get all frameworks.

A loadUnit is a directory that can be loaded by EggLoader, cause it has the same structure.

This function will get add loadUnits follow the order:

1. plugin
2. framework
3. app

loadUnit has a path and a type. Type must be one of those values: app, framework, plugin.

{
  path: 'path/to/application',
  type: 'app'
}

To get application name from package.json

Get the infomation of the application

• pkg: package.json
• name: the application name from package.json
• baseDir: current directory of application
• env: equals to serverEnv
• HOME: home directory of the OS
• root: baseDir when local and unittest, HOME when other environment

To load a single file. Note: The file must export as a function.

To load files from directory in the application.

Invoke this.loadToApp('$baseDir/app/controller', 'controller'), then you can use it by app.controller.

To load files from directory, and it will be bound the context.

// define service in app/service/query.js
module.exports = class Query {
  constructor(ctx) {
    // get the ctx
  }

  get() {}
};

// use the service in app/controller/home.js
module.exports = function*() {
  this.body = this.service.query.get();
};

Loader app/extend/xx.js to target, For example,

this.loadExtend('application', app);

Please open an issue here.

MIT