Services

You need some way to use dependencies in your command module. Services to the rescue!

1
import { CoreDependencies, Singleton } from "@sern/handler";
2
import { Client } from "discord.js";
3

4
interface Dependencies extends CoreDependencies {
5
  "@sern/client": Singleton<Client>;
6
}

Special Dependencies

Some keys in Dependencies are special and are used by sern internally:

@sern/client: Your Discord client. → Emitter
@sern/logger: Logging data → Logging
@sern/errors: Handling errors and lifetime → ErrorHandling
@sern/modules: Managing all command modules → ModuleManager
@sern/emitter: The key to emit events and occurences in a project → Emitter

Usage

Lets try to access the client you provided.

1
import { Service } from "@sern/handler";
2

3
export default commandModule({
4
  // ...
5
  execute: (ctx) => {
6
    // Type is inferred from the dependencies file.
7
    // → Dependencies['@sern/client']
8
    const client = Service("@sern/client");
9
  },
10
  // ...
11
});

Safety

Services cannot be called in other services while makeDependencies is forming.

For example, let’s pass a logger into our database:

1
await makeDependencies({
2
    build: root => root
3
        // Overriding the default logger provided.
4
        .upsert({ '@sern/logger': single(() => new Logger()) })
5

6
        // Wiring our logger into the database.
7
        .add(ctx =>  {
8
            return { database: single(() => new Database(ctx['sern/logger']))) }
9
        })
10
})

1
await makeDependencies({
2
  build: (root) =>
3
    root
4
      // Overriding the default logger provided.
5
      .upsert({ "@sern/logger": single(() => new Logger()) })
6

7
      // Wiring our logger into the database.
8
      // We wire our database incorrectly. Logger should be passed INTO the constructor
9
      .add({ database: single(() => new Database()) }),
10
});

1
import { Service, makeDependencies } from "@sern/handler";
2

3
// Calling Service prematurely!
4
const logger = Service("@sern/logger");
5

6
class Database {
7
  constructor() {
8
    this.logger = logger;
9
  }
10
}

This is a code smell anyway. It breaks encapsulation and defeats the purpose of wiring dependencies

Another Example

A good example
Don't do this

1
await makeDependencies(/* ...pass your options here */)

1
// This is guaranteed to be defined if configured correctly
2
import { Service } from "@sern/handler";
3
const client = Service("@sern/client");

1
import { Service, makeDependencies } from "@sern/handler";
2
/* DON'T USE SERVICES BEFORE CALLING makeDependencies */
3
const logger = Service("@sern/logger");
4

5
await makeDependencies();

Important

Services can only be used after sern has made dependencies.
→ Calling a service before will crash your application.
Services can be safely used outside of a commandModule.
→ Be careful to not cause too many side effects.
You will need to wire dependencies together.
→ This is a good practice to keep your code clean.
Services can only be used after sern has made dependencies.
→ Calling a service before will crash your application.
Services can be safely used outside of a commandModule.
→ Be careful to not cause too many side effects.

Use Service for single dependency.
Use Services for multiple dependencies.