Services

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

src/dependencies.d.ts

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

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

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.

src/commands/ping.ts

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

export default commandModule({
  // ...
  execute: (ctx) => {
    // Type is inferred from the dependencies file.
    // → Dependencies['@sern/client']
    const client = Service("@sern/client");
  },
  // ...
});

Safety

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

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

Example

A good example

index.ts

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

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

Don't do this

index.ts

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

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

index.ts

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

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

class Database {
  constructor() {
    this.logger = logger;
  }
}

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

Another Example

A good example

index.ts

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

commands/ping.ts

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

Don't do this

index.ts

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

await makeDependencies();

Important

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

Related API

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