Egg.js

https://eggjs.org
Admin
Egg.js is an enterprise-grade Node.js and Koa application framework designed to build scalable,...
Tokens:145,278
Snippets:1,337
Trust Score:9.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Initialization on Application Starting

Source: https://eggjs.org/advanced/plugin

Example of defining a task function that executes when the application starts.

```javascript
exports.task = async (ctx) => {
  // your logic code
};
```

--------------------------------

### Start application with EGG_SERVER_ENV

Source: https://eggjs.org/basics/env

Use the EGG_SERVER_ENV environment variable when starting the application to define the runtime environment. Example sets it to 'prod' for production.

```shell
EGG_SERVER_ENV=prod npm start
```

--------------------------------

### Start cluster with egg.startCluster

Source: https://eggjs.org/advanced/framework

Example of using the entry function for the multiprocess launcher to start the Master process.

```javascript
const startCluster = require('egg').startCluster;
startCluster(
  {
    // directory of code
    baseDir: '/path/to/app',
    // directory of framework
    framework: '/path/to/framework',
  },
  () => {
    console.log('app started');
  },
);
```

--------------------------------

### Use bootstrap for setup

Source: https://eggjs.org/core/mock

Using the bootstrap helper to automatically wire common setup and teardown for tests.

```javascript
const { app, mock, assert } = require('egg-mock/bootstrap');

describe('test/controller/home.test.js', () => {
  // test cases
});
```

--------------------------------

### Run development server

Source: https://eggjs.org/intro/quickstart

Start the development server and open the application in your browser.

```bash
npm run dev
open http://localhost:7001
```

--------------------------------

### Example application dependencies

Source: https://eggjs.org/advanced/loader

Example dependency configuration for an application, showing plugin2 depending on plugin3, and framework1 containing plugin1 and inheriting from egg. This is used to illustrate the loading order.

```text
app
| ├── plugin2 (depends plugin3)
| └── plugin3
└── framework1
    | └── plugin1
    └── egg
```

--------------------------------

### Install moment dependency

Source: https://eggjs.org/intro/quickstart

Install the moment library to handle date formatting.

```bash
npm i moment --save
```

--------------------------------

### Initial Directory Structure

Source: https://eggjs.org/intro/progressive

The directory structure for the initial application setup.

```bash
example-app
├── app
│   ├── extend
│   │   └── context.js
│   └── router.js
├── test
│   └── index.test.js
└── package.json
```

--------------------------------

### Deploy single-process bundle

Source: https://eggjs.org/core/bundle

Commands to install production dependencies and start the single-process worker.

```bash
$ npm ci --omit=dev
$ node ./dist-bundle/worker.js
```

--------------------------------

### Initialize project manually

Source: https://eggjs.org/intro/quickstart

Create a project directory and install the necessary egg and egg-bin packages.

```bash
mkdir egg-example
cd egg-example
npm init
npm i egg --save
npm i egg-bin --save-dev
```

--------------------------------

### Start Application with PM2

Source: https://eggjs.org/community/faq

To use PM2, create a server.js file in the project root and then start the application using the pm2 command.

```javascript
// server.js
const egg = require('egg');

const workers = Number(process.argv[2] || require('os').cpus().length);
egg.startCluster({
  workers,
  baseDir: __dirname,
});
```

```bash
pm2 start server.js
```

--------------------------------

### Build and start cluster mode bundle

Source: https://eggjs.org/core/bundle

Commands to build the cluster bundle and start it using egg-scripts.

```bash
$ egg-bin bundle --cluster
$ egg-scripts start --bundle --bundle-dir ./dist-bundle
```

--------------------------------

### Quick Start Unit Test

Source: https://eggjs.org/basics/unittest

A basic example of an HTTP test using @eggjs/mock and Node.js assert.

```typescript
import { app } from '@eggjs/mock/bootstrap';
import assert from 'node:assert';

describe('test/app/controller/home.test.ts', () => {
  it('should GET /', async () => {
    const result = await app.httpRequest().get('/').expect(200);

    assert(result.text === 'hi, egg');
  });
});
```

--------------------------------

### Build Application Package

Source: https://eggjs.org/core/deployment

Install production dependencies and create a compressed archive for deployment.

```bash
$ cd baseDir
$ npm install --production
$ tar -zcvf ../release.tgz .
```

--------------------------------

### Create an app instance

Source: https://eggjs.org/core/mock

Manual setup of an Egg.js application instance for testing.

```javascript
const mock = require('@eggjs/mock');

describe('test/controller/home.test.js', () => {
  let app;

  before(async () => {
    app = mock.app({ baseDir: 'path/to/your/app' });
    await app.ready();
  });

  after(() => app.close());
});
```

--------------------------------

### Install egg-socket.io

Source: https://eggjs.org/tutorials/socketio

Install the plugin via npm.

```bash
$ npm i egg-socket.io --save
```

--------------------------------

### LoaderOptions initializer example

Source: https://eggjs.org/advanced/loader

Shows how to use the initializer option to process each file's exported value during loading. The example includes a model class definition and the loader setup that instantiates the model with app and path. The initializer receives the exported object and an options object containing the current file path.

```javascript
// app/model/user.js
module.exports = class User {
  constructor(app, path) {}
};

// Loading from app/model, could do some initializations when loading.
const directory = path.join(app.config.baseDir, 'app/model');
app.loader.loadToApp(directory, 'model', {
  initializer(model, opt) {
    // The first parameter is export's object
    // The second parameter is an object that only contains current file path.
    return new model(app, opt.path);
  },
});
```

--------------------------------

### Install testing dependencies

Source: https://eggjs.org/intro/quickstart

Install egg-mock as a development dependency.

```bash
npm i egg-mock --save-dev
```

--------------------------------

### Initialize project with scaffold

Source: https://eggjs.org/intro/quickstart

Use the Egg.js scaffold to generate a project structure and install dependencies.

```bash
mkdir egg-example && cd egg-example
npm init egg --type=simple
npm i
```

--------------------------------

### Install @eggjs/mock

Source: https://eggjs.org/core/mock

Command to install the mocking package as a development dependency.

```bash
npm i @eggjs/mock --save-dev
```

--------------------------------

### Test directory structure example

Source: https://eggjs.org/core/unittest

Test files must be placed in the 'test' directory and named with the pattern `${filename}.test.js`. This example shows the expected directory layout.

```bash
test
├── controller
│   └── home.test.js
├── hello.test.js
└── service
    └── user.test.js
```

--------------------------------

### Install egg-passport and egg-passport-github

Source: https://eggjs.org/tutorials/passport

Install the egg-passport plugin and the GitHub strategy package using npm.

```bash
$ npm i --save egg-passport
$ npm i --save egg-passport-github
```

--------------------------------

### Routing Rules Examples (app/router.js)

Source: https://eggjs.org/basics/router

Example of defining routes in `app/router.js`. Shows how to use `router.get`, `router.post` with middleware and controllers. Controllers can be specified directly or as strings, and sub-directories are supported.

```javascript
// app/router.js
module.exports = (app) => {
  const { router, controller } = app;
  router.get('/home', controller.home);
  router.get('/user/:id', controller.user.page);
  router.post('/admin', isAdmin, controller.admin);
  router.post('/user', isLoginUser, hasAdminPermission, controller.user.create);
  router.post('/api/v1/comments', controller.v1.comments.create); // app/controller/v1/comments.js
};
```

--------------------------------

### Configure package.json Scripts

Source: https://eggjs.org/core/deployment

Define start and stop commands in your package.json file.

```json
{
  "scripts": {
    "start": "egg-scripts start --daemon",
    "stop": "egg-scripts stop"
  }
}
```

--------------------------------

### Correct test setup with beforeAll hook

Source: https://eggjs.org/core/unittest

Shows the correct way to run setup code before tests: place it in a beforeAll hook. This ensures the code runs at the intended time during test execution.

```TypeScript
// Good
import { app } from '@eggjs/mock/bootstrap';

describe('good test', () => {
  beforeAll(() => doSomethingBefore());

  it('should redirect', () => {
    return app.httpRequest().get('/').expect(302);
  });
});
```

--------------------------------

### Framework startup sequence diagram

Source: https://eggjs.org/core/cluster-and-ipc

ASCII diagram showing the startup sequence between Master, Agent, and Worker processes.

```bash
    +---------+           +---------+          +---------+
    |  Master |           |  Agent  |          |  Worker |
    +---------+           +----+----+          +----+----+
         |      fork agent     |                    |
         +-------------------->|                    |
         |      agent ready    |                    |
         |<--------------------+                    |
         |                     |     fork worker    |
         +----------------------------------------->|
         |     worker ready    |                    |
         |<-----------------------------------------+
         |      Egg ready      |                    |
         +-------------------->|                    |
         |      Egg ready      |                    |
         +----------------------------------------->|
```

--------------------------------

### GET /api/v2/topics/:id - Response body (JSON)

Source: https://eggjs.org/tutorials/restful

Example response body for the GET /api/v2/topics/:id endpoint. Returns a single topic object with the same fields as the list response.

```json
{
  "id": "57ea257b3670ca3f44c5beb6",
  "author_id": "541bf9b9ad60405c1f151a03",
  "tab": "share",
  "content": "content",
  "title": "Finished Rewriting of Let's Learning Node.js Together",
  "last_reply_at": "2017-01-11T10:20:56.496Z",
  "good": false,
  "top": true,
  "reply_count": 193,
  "visit_count": 47633
}
```

--------------------------------

### GET /api/v2/topics - Response body (JSON)

Source: https://eggjs.org/tutorials/restful

Example response body for the GET /api/v2/topics endpoint. Returns a list of topic objects with fields like id, author_id, tab, content, title, and various counts.

```json
[
  {
    "id": "57ea257b3670ca3f44c5beb6",
    "author_id": "541bf9b9ad60405c1f151a03",
    "tab": "share",
    "content": "content",
    "last_reply_at": "2017-01-11T13:32:25.089Z",
    "good": false,
    "top": true,
    "reply_count": 155,
    "visit_count": 28176,
    "create_at": "2016-09-27T07:53:31.872Z"
  },
  {
    "id": "57ea257b3670ca3f44c5beb6",
    "author_id": "541bf9b9ad60405c1f151a03",
    "tab": "share",
    "content": "content",
    "title": "Finished Rewriting of Let's Learning Node.js Together",
    "last_reply_at": "2017-01-11T10:20:56.496Z",
    "good": false,
    "top": true,
    "reply_count": 193,
    "visit_count": 47633
  }
]
```

--------------------------------

### Controller example: app/controller/home.js and router

Source: https://eggjs.org/core/unittest

Shows a minimal controller and its router configuration. The controller returns 'hello world' as the response body.

```javascript
// app/router.js
module.exports = (app) => {
  const { router, controller } = app;
  router.get('homepage', '/', controller.home.index);
};

// app/controller/home.js
class HomeController extends Controller {
  async index() {
    this.ctx.body = 'hello world';
  }
}
```

--------------------------------

### HttpClient data processing examples

Source: https://eggjs.org/core/httpclient

Demonstrates how data is processed for GET and POST requests, including JSON content type handling.

```javascript
// GET + data
ctx.curl(url, {
  data: { foo: 'bar' },
});

// POST + data
ctx.curl(url, {
  method: 'POST',
  data: { foo: 'bar' },
});

// POST + JSON + data
ctx.curl(url, {
  method: 'POST',
  contentType: 'json',
  data: { foo: 'bar' },
});
```

--------------------------------

### HTTPHeaders decorator to get request headers

Source: https://eggjs.org/basics/httpcontroller

Uses the HTTPHeaders decorator to inject the complete request headers. Note that header keys are converted to lowercase, so access them with lowercase names. The example shows a GET endpoint that reads a custom header 'x-custom'.

```typescript
import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPHeaders, IncomingHttpHeaders } from 'egg';

@HTTPController()
export default class ArgsController {
  // curl http://localhost:7001/api/hello -H 'X-Custom: custom'
  @HTTPMethod({ method: HTTPMethodEnum.GET, path: '/api/hello' })
  async getHeaders(@HTTPHeaders() headers: IncomingHttpHeaders) {
    const custom = headers['x-custom'];
    // ...
  }
}
```

--------------------------------

### Directory structure of example-framework

Source: https://eggjs.org/intro/progressive

The standard directory layout for an Egg.js-based framework.

```bash
example-framework
├── config
│   ├── config.default.js
│   └── plugin.js
├── lib
│   ├── agent.js
│   └── application.js
├── test
│   ├── fixtures
│   │   └── test-app
│   └── framework.test.j.
├── README.md
├── index.js
└── package.json
```

--------------------------------

### Example output of npm run debug

Source: https://eggjs.org/core/development

The console output when starting the application in debug mode, showing debugger listeners and the DevTools proxy URL.

```bash
➜  showcase git:(master) ✗ npm run debug

> showcase@1.0.0 debug /Users/tz/Workspaces/eggjs/test/showcase
> egg-bin debug

Debugger listening on ws://127.0.0.1:9229/f8258ca6-d5ac-467d-bbb1-03f59bcce85b
For help see https://nodejs.org/en/docs/inspector
2017-09-14 16:01:35,990 INFO 39940 [master] egg version 1.8.0
Debugger listening on ws://127.0.0.1:5800/bfe1bf6a-2be5-4568-ac7d-69935e0867fa
For help see https://nodejs.org/en/docs/inspector
2017-09-14 16:01:36,432 INFO 39940 [master] agent_worker#1:39941 started (434ms)
Debugger listening on ws://127.0.0.1:9230/2fcf4208-4571-4968-9da0-0863ab9f98ae
For help see https://nodejs.org/en/docs/inspector
9230 opened
Debug Proxy online, now you could attach to 9999 without worry about reload.
DevTools → chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:9999/__ws_proxy__
```

--------------------------------

### Send messages after egg-ready in app.js

Source: https://eggjs.org/core/cluster-and-ipc

Example app.js that uses app.messenger to send messages to Agent and App processes. Messages can only be sent after the 'egg-ready' event fires, ensuring all processes are started.

```javascript
// app.js
module.exports = (app) => {
  // Note, only after egg-ready event occurs can the message be sent
  app.messenger.once('egg-ready', () => {
    app.messenger.sendToAgent('agent-event', { foo: 'bar' });
    app.messenger.sendToApp('app-event', { foo: 'bar' });
  });
};
```

--------------------------------

### Access Helper in Controller (app/controller/user.js)

Source: https://eggjs.org/basics/objects

Shows how to get the Helper instance via ctx.helper in a Controller. The example uses ctx.helper.formatUser(user) to format a user object and sets it as the response body.

```javascript
// app/controller/user.js
class UserController extends Controller {
  async fetch() {
    const { app, ctx } = this;
    const id = ctx.query.id;
    const user = app.cache.get(id);
    ctx.body = ctx.helper.formatUser(user);
  }
}
```

--------------------------------

### Initiate Framework Testing with mock.app

Source: https://eggjs.org/advanced/framework

Demonstrates how to initialize a framework test using mock.app. The framework option is required to point to the current directory, and app.ready() must be awaited.

```javascript
const mock = require('@eggjs/mock');
describe('test/index.test.js', () => {
  let app;
  before(() => {
    app = mock.app({
      // test/fixtures/apps/example
      baseDir: 'apps/example',
      // importent !! Do not miss
      framework: true,
    });
    return app.ready();
  });

  after(() => app.close());
  afterEach(mock.restore);

  it('should success', () => {
    return app.httpRequest().get('/').expect(200);
  });
});
```

--------------------------------

### loadToContext example: loading services into ctx

Source: https://eggjs.org/advanced/loader

Shows how to use app.loader.loadToContext to load service files into ctx with lazy instantiation. The example includes the service class definition and the loader setup in app.js. The call option is true so the exported class is returned, and fieldClass stores the class in app.serviceClasses. Instances are created on first access via ctx.service.user and cached per request.

```javascript
// The following is just an example, using loadService in practice
// app/service/user.js
const Service = require('egg').Service;
class UserService extends Service {}
module.exports = UserService;

// app.js
// get all loadUnit
const servicePaths = app.loader.getLoadUnits().map((unit) => path.join(unit.path, 'app/service'));

app.loader.loadToContext(servicePaths, 'service', {
  // service needs to inherit app.Service, so needs app as parameter
  // enable call will return UserService when loading
  call: true,
  // loading file into app.serviceClasses
  fieldClass: 'serviceClasses',
});
```

--------------------------------

### Class-based AppBootHook for beforeStart

Source: https://eggjs.org/advanced/loader-update

The recommended approach using didLoad for plugins and willReady for applications to replace beforeStart.

```javascript
// app.js or agent.js:
class AppBootHook {
  constructor(app) {
    this.app = app;
  }

  async didLoad() {
    // Please put your codes of `app.beforeStart` here for your plugin
  }

  async willReady() {
    // Please put your codes of `app.beforeStart` here for your application
  }
}

module.exports = AppBootHook;
```

--------------------------------

### Implementing a Plugin with app.addSingleton

Source: https://eggjs.org/advanced/plugin

Demonstrates how to use app.addSingleton to mount a service instance and initialize it with a creator function.

```javascript
// egg-mysql/app.js
module.exports = (app) => {
  // The first parameter mysql defines the field  mounted to app, we can access MySQL singleton instance via `app.mysql`
  // The second parameter createMysql accepts two parameters (config, app), and then returns a MySQL instance
  app.addSingleton('mysql', createMysql);
};

/**
 * @param  {Object} config   The config is processed by the framework. If the application is configured with multiple MySQL instances, each config would be passed in and call multiple createMysql
 * @param  {Application} app  the current application
 * @return {Object}          return the created MySQL instance
 */
function createMysql(config, app) {
  assert(config.host && config.port && config.user && config.database);
  // create instance
  const client = new Mysql(config);

  // check before start the application
  app.beforeStart(async () => {
    const rows = await client.query('select now() as currentTime;');
    app.coreLogger.info(`[egg-mysql] init instance success, rds currentTime: ${rows[0].currentTime}`);
  });

  return client;
}
```

--------------------------------

### Generate manifest in Dockerfile with npx egg-bin manifest generate

Source: https://eggjs.org/core/manifest

Dockerfile steps for container deployment: install production dependencies, build, generate the startup manifest with npx egg-bin manifest generate --env=prod, then start the app. The manifest is used automatically on startup.

```dockerfile
# Install dependencies and build
RUN npm install --production
RUN npm run build

# Generate startup manifest
RUN npx egg-bin manifest generate --env=prod

# Start the app (manifest is used automatically)
CMD ["npm", "start"]
```

--------------------------------

### Perform a GET request with ctx.curl

Source: https://eggjs.org/core/httpclient

Demonstrates a basic GET request to an external API. The HttpClient defaults to GET if no method is specified.

```javascript
// app/controller/npm.js
class NpmController extends Controller {
  async get() {
    const ctx = this.ctx;
    const result = await ctx.curl('https://httpbin.org/get?foo=bar');
    ctx.status = result.status;
    ctx.set(result.headers);
    ctx.body = result.data;
  }
}
```

--------------------------------

### Asynchronous Plugin Initialization

Source: https://eggjs.org/advanced/plugin

Shows how to use an async function for initialization when configuration needs to be fetched asynchronously.

```javascript
async function createMysql(config, app) {
  // get mysql configurations asynchronous
  const mysqlConfig = await app.configManager.getMysqlConfig(config.mysql);
  assert(mysqlConfig.host && mysqlConfig.port && mysqlConfig.user && mysqlConfig.database);
  // create instance
  const client = new Mysql(mysqlConfig);

  // check before start the application
  const rows = await client.query('select now() as currentTime;');
  app.coreLogger.info(`[egg-mysql] init instance success, rds currentTime: ${rows[0].currentTime}`);

  return client;
}
```

--------------------------------

### Initialize a new framework scaffold

Source: https://eggjs.org/advanced/framework

Commands to create a new directory, initialize the egg framework scaffold, install dependencies, and run tests.

```bash
$ mkdir yadan && cd yadan
$ npm init egg --type=framework
$ npm i
$ npm test
```

--------------------------------

### Install passport-local

Source: https://eggjs.org/tutorials/passport

Command to install the passport-local strategy package via npm.

```bash
$ npm i --save passport-local
```

--------------------------------

### Install egg-view-nunjucks plugin

Source: https://eggjs.org/core/view

Install the egg-view-nunjucks plugin as a dependency for your Egg.js application.

```bash
$ npm i egg-view-nunjucks --save
```

--------------------------------

### Asynchronous Agent Startup with agent.beforeStart

Source: https://eggjs.org/advanced/plugin

Use the agent.beforeStart API to perform asynchronous initialization tasks for the agent process.

```javascript
// ${plugin_root}/agent.js
const MyClient = require('my-client');

module.exports = (agent) => {
  agent.myClient = new MyClient();
  agent.myClient.on('error', (err) => {
    agent.coreLogger.error(err);
  });
  agent.beforeStart(async () => {
    await agent.myClient.ready();
    agent.coreLogger.info('my client is ready');
  });
};
```

--------------------------------

### Render templates with ctx.render, renderView, and renderString

Source: https://eggjs.org/core/view

Example controller showing the three rendering interfaces: render, renderView, and renderString. renderString requires a viewEngine unless defaultViewEngine is set.

```js
// {app_root}/app/controller/home.js
class HomeController extends Controller {
  async index() {
    const data = { name: 'egg' };

    // render a template, path relate to `app/view`
    await ctx.render('home/index.tpl', data);

    // or manually set render result to ctx.body
    ctx.body = await ctx.renderView('path/to/file.tpl', data);

    // or render string directly
    ctx.body = await ctx.renderString('hi, {{ name }}', data, {
      viewEngine: 'nunjucks',
    });
  }
}
```

--------------------------------

### Initialize Socket.io Client in Browser

Source: https://eggjs.org/tutorials/socketio

Example of initializing a socket connection in the browser with query parameters and event listeners for p2p communication.

```javascript
// browser
const log = console.log;

window.onload = function () {
  // init
  const socket = io('/', {
    // Actual use can pass parameters here
    query: {
      room: 'demo',
      userId: `client_${Math.random()}`,
    },

    transports: ['websocket'],
  });

  socket.on('connect', () => {
    const id = socket.id;

    log('#connect,', id, socket); // receive online user information

    // listen for its own id to implement p2p communication
    socket.on(id, (msg) => {
      log('#receive,', msg);
    });
  });

  socket.on('online', (msg) => {
    log('#online,', msg);
  });

  // system events
  socket.on('disconnect', (msg) => {
    log('#disconnect', msg);
  });

  socket.on('disconnecting', () => {
    log('#disconnecting');
  });

  socket.on('error', () => {
    log('#error');
  });

  window.socket = socket;
};
```

--------------------------------

### Install egg-dev as devDependency

Source: https://eggjs.org/basics/plugin

Install the egg-dev plugin as a devDependency and add it to package.json. This is used for environment-specific plugin loading.

```js
// npm i egg-dev --save-dev
// package.json
{
  "devDependencies": {
    "egg-dev": "*"
  }
}
```

--------------------------------

### Start Application with egg-scripts

Source: https://eggjs.org/core/deployment

Launch the application in production mode using egg-scripts with specific configuration flags.

```bash
$ egg-scripts start --port=7001 --daemon --title=egg-server-showcase
```

--------------------------------

### Asynchronous Application Startup with beforeStart

Source: https://eggjs.org/advanced/plugin

Use the app.beforeStart API to perform asynchronous initialization tasks before the application is ready.

```javascript
// ${plugin_root}/app.js
const MyClient = require('my-client');

module.exports = (app) => {
  app.myClient = new MyClient();
  app.myClient.on('error', (err) => {
    app.coreLogger.error(err);
  });
  app.beforeStart(async () => {
    await app.myClient.ready();
    app.coreLogger.info('my client is ready');
  });
};
```

--------------------------------

### Install egg-mysql plugin via npm

Source: https://eggjs.org/basics/plugin

Install the egg-mysql plugin using npm. The command is run in the terminal.

```bash
$ npm i egg-mysql --save
```

--------------------------------

### Service example: app/service/user.js

Source: https://eggjs.org/core/unittest

Shows a service class that fetches a user by name from a user database.

```javascript
// app/service/user.js
class UserService extends Service {
  async get(name) {
    return await userDatabase.get(name);
  }
}
```

--------------------------------

### GET request response from Koa server

Source: https://eggjs.org/core/security

Response from a GET request to the Koa server, showing the httpOnly cookie being set.

```http
HTTP/1.1 200 OK
X-Powered-By: koa
Set-Cookie: a=1; path=/; httponly
Content-Type: text/plain; charset=utf-8
Content-Length: 2
Date: Thu, 06 Nov 2014 05:04:42 GMT
Connection: keep-alive

OK
```

--------------------------------

### Package the application

Source: https://eggjs.org/core/manifest

Create a compressed archive of the project, including the generated .egg/manifest.json file.

```bash
tar -zcvf release.tgz .
```

--------------------------------

### Install egg-bin dependency

Source: https://eggjs.org/core/development

Install the egg-bin module as a development dependency to enable local development and unit testing tools.

```bash
$ npm i egg-bin --save-dev
```

--------------------------------

### Mock service method with app.mockService

Source: https://eggjs.org/core/unittest

Use app.mockService('user', 'get', fn) to mock the get(name) method in app/service/user to return a nonexistent user. The test sends a GET request to /user?name=fengmk1 and expects a 200 status with the mocked user object.

```javascript
it('should mock fengmk1 exists', () => {
  app.mockService('user', 'get', () => {
    return {
      name: 'fengmk1',
    };
  });

  return (
    app
      .httpRequest()
      .get('/user?name=fengmk1')
      .expect(200)
      // return an originally nonexistent user
      .expect({
        name: 'fengmk1',
      })
  );
});
```

--------------------------------

### Configuration file using exports.key = value

Source: https://eggjs.org/basics/config

A shorthand format for configuration files, setting keys and logger level directly.

```js
exports.keys = 'my-cookie-secret-key';
exports.logger = {
  level: 'DEBUG',
};
```

--------------------------------

### Error: framework.RouterConflictError for GET /apps/:id

Source: https://eggjs.org/faq/TEGG_ROUTER_CONFLICT

The error message shown when a route conflict is detected. It indicates that the GET /apps/:id route is already registered.

```bash
framework.RouterConflictError: register http controller GET AppController2.get failed, GET /apps/:id is conflict with exists rule /apps/:id
```

--------------------------------

### Initialize plugin with npm init egg --type=plugin

Source: https://eggjs.org/tutorials/passport

Run this command to scaffold a new egg plugin named egg-passport-local.

```bash
$ npm init egg --type=plugin egg-passport-local
```
Tokens:
Raw