@odg/events

Stanley The Template For Typescript By Dragons Gamers

Template Stanley for Typescript projects and packages 📦!

Table of Contents

• 🎇 Benefits
• 📗 Libraries
• 📁 Dependencies
• ⏩ Get Started
  • 🔘 Use Event Interface
  • 📰 Usage
  • 🌎 Implementation
  • 🌎 Ioc
  • 🏓 Use Event Provider
    • 🚡 Enum Events Types
    • 🥮 Make a provider
    • 🦻 Use Event Listeners
  • 💻 Prepare to develop
  • 📍 Start Project
  • 📨 Build and Run
  • 🧪 Teste Code

🎇 Benefits

• 🚀 Event Pattern for your project
• 🚨 Over 800 rules for pattern, possible errors and errors in Linter
• 🎇 Code quality guaranteed
• 📢 Ioc Container
• 🧪 100% Test Coverage

📗 Libraries

• Node.js 16
• Typescript
• Eslint
• ODG-Linter-JS
• EditorConfig
• ReviewDog

📁 Dependencies

• Node.js 16 or later
• Yarn Optional/Recommended
• ODG TsConfig Last Version

⏩ Get Started

🔘 Use Event Interface

Install in your project using this command

yarn add @odg/events

📰 Usage

🌎 Implementation

interface EventType {
    "event1": number, // receive number
    "userRegister": {
        name: string,
        age: number
    } // receive object,
}

const eventBus = new EventEmitterBus<EventType>();
const callback = (eventMessage: string) => {
    console.log(eventMessage);
};

eventBus.subscribe("event1", callback); // Subscribe before dispatch
eventBus.dispatch("event1", 1); // Send 1 to event1
eventBus.dispatch("userRegister", { name: "ODGodinho", age: 18 }); // Send object to userRegister

🌎 Ioc

class Example {
    public constructor(
        private eventBus: EventEmitterBus<EventType>
    ) {
    }

    public example(){
        // code ...
        this.eventBus.dispatch("event1", 1);
        // code ...
    }
}

🏓 Use Event Provider

🚡 Enum Events Types

enum EventName {
    Example = "Example",
}

import { type EventObjectType } from "@odg/events";

import { type EventName } from "../app/Enums";

export interface EventExampleParameters {
    // anything params
}

export interface EventBaseInterface extends EventObjectType {
    [EventName.Example]: EventExampleParameters;
}

// IF the above interface does not have all existing laws in the enum it will report an error
export type EventTypes<T extends Record<EventName, unknown> = EventBaseInterface> = T;

🥮 Make a provider

import {
    EventBusInterface,
    EventServiceProvider as EventServiceProviderBase,
    type EventListener,
} from "@odg/events";
import {
    Container,
    inject, injectable,
} from "inversify";

import { type EventTypes } from "../../Interfaces/EventsInterface";
import { ContainerName, EventName } from "../Enums";
import { type HomeEventListeners } from "../Listeners/HomeEventListeners";

@injectable()
export class EventServiceProvider extends EventServiceProviderBase<EventTypes> {

    @inject(ContainerName.EventBus)
    protected bus!: EventBusInterface<Events>;

    /**
     * Listeners for events in the application.
     *
     * @protected
     * @type {EventListener<EventTypes>}
     * @memberof EventServiceProvider
     */
    protected listeners: EventListener<EventTypes> = {
        [EventName.Example]: [
            {
                listener: new HomeEventListeners(), // You can use inversify
                options: {},
            },
        ],
    };

    public async boot(): Promise<void> {
        await super.boot();
    }

    public async shutdown(): Promise<void> {
        await super.shutdown();
    }

}

🦻 Use Event Listeners

import { type EventListenerInterface } from "@odg/events";
import { LoggerInterface } from "@odg/log";
import { inject, injectable } from "inversify";

import { type EventExampleType, type EventTypes } from "../../Interfaces/EventsInterface";
import { ContainerName, type EventName } from "../Enums"; // If use inversify
import { PageFactoryType } from "../Factory/PageFactory";

@injectable()
export class HomeEventListeners implements EventListenerInterface<EventTypes, EventName.Example> {

    @inject(ContainerName.Logger) // You can use constructor to inject
    public log!: LoggerInterface;

    public async handler({ page }: EventExampleType): Promise<void> {
        await this.log.debug("HomeEventListeners is sended");
    }

}

💻 Prepare To Develop

Copy .env.example to .env and add the values according to your needs.

📍 Start Project

First install dependencies with the following command

yarn install
# or
npm install

📨 Build and Run

To build the project, you can use the following command

if you change files, you need to run yarn build and yarn start again

yarn build && yarn start
# or
yarn dev

🧪 Teste Code

To Test execute this command

yarn test
# or
yarn test:watch