Danet Framework

Danet is a TypeScript framework designed for building efficient and scalable server-side applications on Deno.

Key characteristics:

• Inspired by NestJS: It adopts a professional application architecture (originally inspired by Angular) to promote highly testable, scalable, and loosely coupled code.
• Powered by Hono: Under the hood, Danet utilizes Hono for its underlying web capabilities.
• Abstraction-focused: It abstracts low-level details so developers can focus on core business logic and architecture.

To start building applications with Danet, install the CLI globally using Deno. The CLI allows you to scaffold new projects easily.

Note: Since version 2.4.0, Danet is distributed via JSR at @danet/core to support runtime agnosticism.

deno install --global -A -n danet jsr:@danet/cli

Once the CLI is installed, use the danet new command followed by your desired project name to scaffold a new application structure.

danet new <my-project>

Danet supports pluggable transports (like gRPC) that can take ownership of specific controllers. If a controller carries a specific metadata key, it will be delegated to the registered transport instead of the default HTTP or WebSocket routers.

To use an external transport:

1. Implement the TransportRouter interface.
2. Register it using useTransport(metadataKey, transport) before calling init().

export interface TransportRouter {
	registerController(Controller: Constructor, metadataValue: unknown): void;
}

// Usage
app.useTransport('grpc-metadata-key', myGrpcTransport);
await app.init(FirstModule);

To start a Danet application, instantiate DanetApplication, initialize it with a root Module, and then call listen() to start the server. The init() method bootstraps the module, resolves dependencies via the injector, and executes the APP_BOOTSTRAP hook for all injectables.

import {
	Controller,
	DanetApplication,
	Get,
	Module,
	Param,
} from '../src/mod.ts';

@Controller('')
class FirstController {
	@Get('hello-world/:name')
	getHelloWorld(@Param('name') name: string) {
		return `Hello World ${name}`;
	}
}

@Module({
	controllers: [FirstController]
})
class FirstModule {}

const app = new DanetApplication();
await app.init(FirstModule);

const port = Number(Deno.env.get('PORT')) || 3000;
app.listen(port);

When setting up a throttler, use the ThrottlerOptions interface to define the rate limiting rules. You can configure multiple throttlers to handle different scenarios, such as short bursts versus long-term sustained limits. Each throttler requires a ttl (time-to-live in milliseconds) and a limit (maximum requests allowed within that window). You can optionally provide a name to identify the throttler; if omitted, it defaults to default.

// Example configuration for a single throttler
const options: ThrottlerOptions = {
  name: 'burst',
  ttl: 1000,
  limit: 5,
};

You can prevent the Logger class from printing any messages to the console by setting the NO_LOG environment variable in your Deno environment. When this variable is present, all calls to .log(), .warn(), and .error() will return without outputting anything.

# Example of running your application with logging disabled
NO_LOG=true deno run src/main.ts

The @SSE decorator is used to define a method that handles Server-Sent Events. The method should return an EventTarget which is used to dispatch events to the client.

@SSE('/stream')
public myMethod(): EventTarget {
  const eventTarget = new EventTarget();
  let id = 0;
  const interval = setInterval(() => {
    if (id >= 4) {
      clearInterval(interval);
      const event = new SSEEvent({
        retry: 1000,
        id: `${id}`,
        data: 'close',
        event: 'close',
      });
      eventTarget.dispatchEvent(event);
      return;
    }
    const event = new SSEEvent({
      retry: 1000,
      id: `${id}`,
      data: 'world',
      event: 'hello',
    });
    eventTarget.dispatchEvent(event);
    id++;
  }, 100);
  return eventTarget;
}

The @Header decorator allows you to access request headers.

• @Header(): Injects the entire headers object.
• @Header('header-name'): Injects the value of a specific header.

Example:

@Get()
async getHeaders(@Header() allHeaders: Record<string, string>, @Header('authorization') auth: string) {
  // ...
}

To expose your controller methods as HTTP routes, use the registerController method on an instance of DanetHTTPRouter. This method iterates through the controller's prototype and registers methods as routes based on their metadata (like @Get(), @Post(), etc.).

registerController(Controller: Constructor, basePath: string)

• Controller: The class constructor of your controller.
• basePath: The base path prefix for all routes within this controller.

router.registerController(MyController, 'api/v1');