tritio 0.1.1 → 0.2.0

package/README.md

@@ -1,15 +1,146 @@
-# core
+# Tritio
 
-To install dependencies:
+**The fast, opinionated H3 framework.**
+
+Tritio is a modern backend framework built on top of [H3](https://github.com/unjs/h3) (the HTTP engine behind Nuxt and Nitro). It is designed to run natively on **Bun**, but is fully compatible with any environment that supports Web Standards (Node.js, Cloudflare Workers, etc.).
+
+Its core philosophy is **Extreme End-to-End Type Safety** and **Performance**, combining the raw speed of H3 with a superior Developer Experience (DX) inspired by tools like ElysiaJS and Fastify, but architected for robust, enterprise-grade applications.
+
+## Core Features
+
+- **Built on H3 (Web Standards)**: Leverages the performance and compatibility of the H3 engine.
+- **TypeBox First-Class Integration**: Native input validation and automatic type inference for Body, Query, and Params. No more manual interface duplication.
+- **Modular & Scalable**: Native support for nested applications via `.mount()`. Perfect for monorepos and Vertical Slicing architectures.
+- **Auto-Documentation**: Automatic OpenAPI 3.1 generation and integrated [Scalar](https://scalar.com/) UI for testing your API.
+- **Developer Experience**: Fluent, chainable API request handling (`app.get(...).post(...)`), centralized error handling, and robust CORS support.
+
+## Quick Start
+
+### Installation
+
+Tritio works best with Bun, but you can use your preferred package manager.
 
 ```bash
-bun install
+bun add tritio
 ```
 
-To run:
+### Hello World
+
+Create a simple server in `src/index.ts`:
+
+```typescript
+import { Tritio, t } from "tritio";
+
+const app = new Tritio();
+
+app.get(
+  "/",
+  {
+    response: t.String(),
+  },
+  () => "Hello from Tritio"
+);
+
+app.listen(3000);
+```
+
+Run it with:
 
 ```bash
-bun run index.ts
+bun run src/index.ts
 ```
 
-This project was created using `bun init` in bun v1.3.4. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+## Features in Detail
+
+### End-to-End Type Safety
+
+Tritio infers TypeScript types directly from your validation schemas. You define the schema, and `ctx.body`, `ctx.query`, and your return types are strongly typed.
+
+```typescript
+import { Tritio, t } from "tritio";
+
+const app = new Tritio();
+
+app.post(
+  "/users",
+  {
+    body: t.Object({
+      name: t.String(),
+      age: t.Number(),
+    }),
+    response: t.Object({
+      id: t.Number(),
+      message: t.String(),
+    }),
+  },
+  (ctx) => {
+    // ctx.body is strictly typed: { name: string; age: number }
+    const { name, age } = ctx.body;
+
+    return {
+      id: 1,
+      message: `User ${name} created successfully`,
+    };
+  }
+);
+```
+
+### Modular Architecture (Grouping & Mounting)
+
+Tritio shines in complex applications. You can group routes or mount entirely separate application instances.
+
+#### Grouping Routes
+
+Organize related routes under a common prefix.
+
+```typescript
+app.group("/api/v1", (api) => {
+  api.get("/status", {}, () => ({ status: "ok" }));
+
+  api.group("/users", (users) => {
+    users.get("/", {}, () => ["Alice", "Bob"]);
+  });
+});
+```
+
+#### Mounting Sub-Apps
+
+For larger systems, separate your domains into independent Tritio instances and assemble them.
+
+```typescript
+// auth.module.ts
+const authApp = new Tritio();
+authApp.post("/login", {}, () => "Login logic");
+
+// billing.module.ts
+const billingApp = new Tritio();
+billingApp.get("/invoices", {}, () => ["Inv-001", "Inv-002"]);
+
+// main.ts
+const app = new Tritio();
+app.mount("/auth", authApp); // Accessible at /auth/login
+app.mount("/billing", billingApp); // Accessible at /billing/invoices
+```
+
+### Auto-Documentation
+
+Tritio automatically generates an OpenAPI 3.1 specification from your routes and schemas. It includes **Scalar**, a modern and beautiful API reference UI.
+
+Simply call `app.docs()` to enable it.
+
+```typescript
+const app = new Tritio();
+
+// ... define your routes ...
+
+// Enable documentation at /docs
+app.docs();
+
+app.listen(3000);
+```
+
+Visit `http://localhost:3000/docs` to explore and test your API.
+
+## License
+
+MIT

package/dist/core/context.d.ts

@@ -0,0 +1,9 @@
+import { H3Event } from 'h3';
+import { Context, RouteSchema } from '../types';
+export type InternalContext<S extends RouteSchema, Env> = Context<S, Env> & {
+    _query?: Record<string, unknown>;
+    _params?: Record<string, unknown>;
+};
+export declare class ContextFactory {
+    static create<S extends RouteSchema, Env>(event: H3Event, rawBody: unknown): Context<S, Env>;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './pipeline';
+export * from './context';

package/dist/core/pipeline.d.ts

@@ -0,0 +1,6 @@
+import { EventHandlerResponse, H3Event } from 'h3';
+import { HTTPMethod } from '../http';
+import { Context, MiddlewareHandler, RouteSchema } from '../types';
+export declare class ExecutionPipeline {
+    static build<S extends RouteSchema, Env>(schema: S, middlewares: MiddlewareHandler<Env>[], handler: (ctx: Context<S, Env>) => unknown, method: HTTPMethod): (event: H3Event) => Promise<EventHandlerResponse>;
+}

package/dist/docs/openapi.d.ts

@@ -1,9 +1,20 @@
-export declare const generateOpenApiSpec: (routes: any[]) => {
+import { HTTPMethod } from '../http/methods';
+import { RouteSchema } from '../types';
+interface Route {
+    method: HTTPMethod;
+    path: string;
+    schema: RouteSchema;
+}
+interface OpenApiPaths {
+    [key: string]: Record<string, unknown>;
+}
+export declare const generateOpenApiSpec: (routes: Route[]) => {
     openapi: string;
     info: {
         title: string;
         version: string;
         description: string;
     };
-    paths: any;
+    paths: OpenApiPaths;
 };
+export {};

package/dist/{error/http-error.d.ts → http/errors.d.ts}

@@ -1,3 +1,4 @@
+import { HTTPError as H3Error } from 'h3';
 export interface HTTPErrorOptions {
     res?: Response;
     message?: string;
@@ -65,3 +66,4 @@ export declare class ServiceUnavailableException extends HTTPError {
 export declare class GatewayTimeoutException extends HTTPError {
     constructor(options?: HTTPErrorOptions);
 }
+export declare const errorHandler: (error: H3Error | HTTPError) => Response;

package/dist/http/index.d.ts

@@ -1,2 +1,3 @@
 export * from './methods';
 export * from './cors';
+export * from './errors';

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export * from './schema';
+import { Tritio } from './tritio';
 export * from './types';
 export * from './tritio';
-export * from './error/http-error';
-export * from './error/handler';
+export * from './validation';
+export * from './core';
 export * from './docs';
 export * from './http';
+export type InferApp<T> = T extends Tritio<any, infer S> ? S : never;