@vyriy/router 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyriy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,85 @@
+# @vyriy/router
+
+Router utility for Vyriy projects.
+
+## Purpose
+
+This package provides a small API Gateway router for Lambda handlers.
+
+It is intentionally kept small:
+
+- matches by HTTP method and exact path
+- passes API Gateway event data into handlers
+- returns a Lambda-friendly response shape
+
+It does not try to be a path parser or dispatcher. If you later need regular expressions, wildcard matching, route params extraction, or more advanced dispatch rules, that logic should live in a separate package or layer.
+
+## Install
+
+With npm:
+
+```bash
+npm install @vyriy/router
+```
+
+With Yarn:
+
+```bash
+yarn add @vyriy/router
+```
+
+## Usage
+
+```ts
+import { createRouter } from '@vyriy/router';
+
+const router = createRouter();
+
+router.get('/health', async ({ event, query, headers, pathParameters, body }) => ({
+  statusCode: 200,
+  body: JSON.stringify({
+    ok: true,
+    method: event.httpMethod,
+    query,
+    headers,
+    pathParameters,
+    body,
+  }),
+}));
+```
+
+## Exports
+
+The package exposes both the root entry and the direct module entry:
+
+```ts
+import { createRouter } from '@vyriy/router';
+import { Router } from '@vyriy/router/router';
+```
+
+## API
+
+- `createRouter()` returns a chainable router API.
+- `router.get(path, handler)` registers a `GET` handler.
+- `router.post(path, handler)` registers a `POST` handler.
+- `router.put(path, handler)` registers a `PUT` handler.
+- `router.delete(path, handler)` registers a `DELETE` handler.
+- `router.patch(path, handler)` registers a `PATCH` handler.
+- `router.route(event)` resolves the matching route and returns an API Gateway response.
+
+The low-level `Router` class is also available from `@vyriy/router/router` and exposes only:
+
+- `router.on(method, path, handler)`
+- `router.route(event)`
+
+Route handlers receive:
+
+```ts
+type HandlerParams = {
+  query?: APIGatewayProxyEventQueryStringParameters;
+  body?: string;
+  headers?: APIGatewayProxyEvent['headers'];
+  pathParameters?: APIGatewayProxyEvent['pathParameters'];
+  event: APIGatewayProxyEvent;
+};
+```

package/create.d.ts

@@ -0,0 +1,2 @@
+import type { RouterApi } from './types.js';
+export declare const createRouter: () => RouterApi;

package/create.js

@@ -0,0 +1,30 @@
+import { Router } from './router.js';
+export const createRouter = () => {
+    const router = new Router();
+    const api = {
+        get(path, handler) {
+            router.on('GET', path, handler);
+            return api;
+        },
+        post(path, handler) {
+            router.on('POST', path, handler);
+            return api;
+        },
+        put(path, handler) {
+            router.on('PUT', path, handler);
+            return api;
+        },
+        delete(path, handler) {
+            router.on('DELETE', path, handler);
+            return api;
+        },
+        patch(path, handler) {
+            router.on('PATCH', path, handler);
+            return api;
+        },
+        route(event) {
+            return router.route(event);
+        },
+    };
+    return api;
+};

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create.js';
+export type * from './types.js';

package/index.js

@@ -0,0 +1 @@
+export * from './create.js';

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@vyriy/router",
+  "version": "0.1.9",
+  "description": "Router utility for Vyriy projects",
+  "type": "module",
+  "main": "./index.js",
+  "dependencies": {
+    "@types/aws-lambda": "^8.10.161"
+  },
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./create": {
+      "types": "./create.d.ts",
+      "import": "./create.js",
+      "default": "./create.js"
+    },
+    "./create.js": {
+      "types": "./create.d.ts",
+      "import": "./create.js",
+      "default": "./create.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./router": {
+      "types": "./router.d.ts",
+      "import": "./router.js",
+      "default": "./router.js"
+    },
+    "./router.js": {
+      "types": "./router.d.ts",
+      "import": "./router.js",
+      "default": "./router.js"
+    }
+  }
+}

package/router.d.ts

@@ -0,0 +1,6 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult, Handler } from './types.js';
+export declare class Router {
+    private readonly routes;
+    on(method: string, path: string, handler: Handler): this;
+    route(event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult>;
+}

package/router.js

@@ -0,0 +1,39 @@
+import { METHODS, STATUS_CODES } from 'node:http';
+const SUPPORTED_METHODS = new Set(METHODS.map((method) => method.toUpperCase()));
+export class Router {
+    routes = {};
+    on(method, path, handler) {
+        const normalizedMethod = method.toUpperCase();
+        if (!SUPPORTED_METHODS.has(normalizedMethod)) {
+            throw new Error(`Unsupported HTTP method: ${normalizedMethod}`);
+        }
+        const routeGroup = (this.routes[normalizedMethod] ??= {});
+        if (routeGroup[path]) {
+            throw new Error(`${normalizedMethod} ${path} already exists!`);
+        }
+        routeGroup[path] = handler;
+        return this;
+    }
+    async route(event) {
+        const { httpMethod, path, queryStringParameters, body, headers, pathParameters } = event;
+        const result = await this.routes[httpMethod]?.[path]?.({
+            query: queryStringParameters ?? undefined,
+            body: body ?? undefined,
+            headers,
+            pathParameters: pathParameters ?? undefined,
+            event,
+        });
+        return result
+            ? {
+                statusCode: result.statusCode ?? 200,
+                body: result.body,
+                headers: result.headers,
+            }
+            : {
+                statusCode: 404,
+                body: JSON.stringify({
+                    message: STATUS_CODES[404],
+                }),
+            };
+    }
+}

package/types.d.ts

@@ -0,0 +1,23 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyResult } from 'aws-lambda';
+export type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+export type Result = {
+    body: APIGatewayProxyResult['body'];
+    headers?: APIGatewayProxyResult['headers'];
+    statusCode?: APIGatewayProxyResult['statusCode'];
+};
+export type HandlerParams = {
+    query?: APIGatewayProxyEventQueryStringParameters;
+    body?: string;
+    headers?: APIGatewayProxyEvent['headers'];
+    pathParameters?: APIGatewayProxyEvent['pathParameters'];
+    event: APIGatewayProxyEvent;
+};
+export type Handler = (params: HandlerParams) => Promise<Result | undefined>;
+export type RouterApi = {
+    get(path: string, handler: Handler): RouterApi;
+    post(path: string, handler: Handler): RouterApi;
+    put(path: string, handler: Handler): RouterApi;
+    delete(path: string, handler: Handler): RouterApi;
+    patch(path: string, handler: Handler): RouterApi;
+    route(event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult>;
+};