A production-ready (almost) compound (template and libs) built up-on elysiajs

[kwaitsing]

Elysia with URN.ts Lite

What is URN.ts Lite?

The original URN.ts was a framework built upon ElysiaJS, designed for large-scale applications with extensive routing.

However, as the Elysia codebase grew, maintaining the URN.ts framework became increasingly difficult.

To address this, URN.ts has been transformed into a library instead of a framework. It now provides a collection of tools and utilities for building robust backends directly on top of ElysiaJS.

Project Initialization

1. Install Bun: Install Bun from bun.sh.
2. Create a Project: Run bunx urn-lite-spinup@latest <projectname>. This command generates a ready-to-use Elysia codebase with URN.ts Lite integrated.

Project Structure

Your application's entry point is src/index.ts. This is where your code execution begins.

URN.ts Lite defaults to the Model-View-Controller (MVC) pattern for development.

In the example aliases below, the .ts extension is typically omitted because TypeScript implicitly recognizes .ts files.

Location	Example Alias	Description	Reference
src/controller	@controller/user.c	Defines specific routes for a resource (as a new Elysia instance). Handles incoming requests and interacts with the model.	Elysia Documentation
src/misc	@misc/type	Stores miscellaneous components outside the main development pattern, such as type definitions and helper functions.
src/model	@model/user.m	Contains the business logic. Typically includes code that interacts with data sources (e.g., databases).
src/schema	@schema/user.s	Houses validation schemas. Extend the types of these schemas to your type.ts files in @misc for strong typing throughout your application.	Elysia Documentation
src/index	-	The application entry point.

Component Overview

Name	Purpose	Documents/Example
Dbi and CDbi (Classes)	Interact with MongoDB and Redis, respectively. Provide automatic sanitization of queries and inputs.	databridge-pack Source Code
Sch2Ts (Type)	Converts Elysia schemas into TypeScript types.	Sch2Ts<typeof userSchema.post>
@elysiajs/swagger, bearer, cors, jwt, and urn-logger	Commonly used official Elysia plugins and a third-party logger for ElysiaJS.	Elysia Plugins Overview

How-To-Use

Basic Usage

Once the template is set up, you'll find numerous comments within the code. Please read these carefully as they provide important guidance.

Recommended Development Workflow

The recommended development workflow follows a specific order:

1. Schema: Begin by defining your data schemas in the src/schema directory. This ensures strong typing and validation from the outset.
2. Model: Next, develop your business logic within the src/model directory. This is where you'll handle data manipulation, database interactions, and core application functionality.
3. Controller: Finally, create separate controller files in the src/controller directory. Each controller is an independent Elysia instance, responsible for handling specific routes related to a particular resource. The routes within each controller module are mounted to this instance.
4. Mount Controller: After defining your controllers, mount them to your main Elysia application instance (typically in src/index.ts).

This approach promotes a clean separation of concerns and makes your codebase more maintainable and scalable.

Logger

URN.ts Lite includes UrnLogger, a simple yet powerful logger. It supports:

• Templated Log Messages: Allows for customizable log message formatting.
• Dual Output: Outputs log messages to both the standard output (console) and files.

The original readme was written in adoc however github discussions doesn't support asciidoc so i use gemini to transpile it into markdown

URN.ts has been running reliably in our production environment for nearly a year, as of the time of writing. Maybe it's luck or idk
**URN.ts lite has been operating stably in our production environment for 3 months, as of this writing. **