tritio 0.1.2 → 0.3.0

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/lifecycle.d.ts

@@ -0,0 +1,20 @@
+import { H3Event, HTTPError as NativeH3Error } from 'h3';
+import { GlobalHook, ErrorHook, TransformHook, ContextHook } from '../types';
+import { HTTPError } from '../http';
+export declare class LifecycleManager<Env> {
+    onRequestHooks: GlobalHook[];
+    onResponseHooks: Array<(response: any, event: H3Event) => void | Promise<void>>;
+    onErrorHooks: ErrorHook[];
+    onTransformHooks: TransformHook<Env>[];
+    onBeforeHandleHooks: ContextHook<Env>[];
+    onAfterHandleHooks: ContextHook<Env>[];
+    addRequest(fn: GlobalHook): void;
+    addResponse(fn: (res: any, event: H3Event) => void): void;
+    addError(fn: ErrorHook): void;
+    addTransform(fn: TransformHook<Env>): void;
+    addBeforeHandle(fn: ContextHook<Env>): void;
+    addAfterHandle(fn: ContextHook<Env>): void;
+    runOnRequest(event: H3Event): Promise<void>;
+    runOnResponse(response: any, event: H3Event): Promise<void>;
+    runOnError(error: HTTPError | NativeH3Error, event: H3Event): Promise<Response>;
+}

package/dist/core/pipeline.d.ts

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

package/dist/core/registry.d.ts

@@ -0,0 +1,12 @@
+import { HTTPMethod } from '../http/methods';
+import { RouteSchema } from '../types';
+export interface RegisteredRoute {
+    method: HTTPMethod;
+    path: string;
+    schema: RouteSchema;
+}
+export declare class RouteRegistry {
+    private routes;
+    add(method: HTTPMethod, path: string, schema: RouteSchema): void;
+    getAll(): RegisteredRoute[];
+}

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

@@ -1,15 +1,19 @@
+import { HTTPError as H3Error } from 'h3';
 export interface HTTPErrorOptions {
     res?: Response;
     message?: string;
     cause?: unknown;
 }
-export declare class HTTPError extends Error {
+export declare class HTTPError extends H3Error {
     readonly status: number;
+    statusText: string;
     readonly res?: Response;
-    readonly cause?: unknown;
+    cause: unknown;
     constructor(status: number, options?: HTTPErrorOptions);
+    get statusCode(): number;
+    get statusMessage(): string;
     getResponse(): Response;
-    private get statusText();
+    private static getStatusText;
 }
 export declare class BadRequestException extends HTTPError {
     constructor(options?: HTTPErrorOptions);
@@ -65,3 +69,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,2 @@
 export * from './methods';
-export * from './cors';
+export * from './errors';

package/dist/index.d.ts

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