@vyriy/server 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,35 @@
+# @vyriy/server
+
+Small HTTP server adapter for running Lambda-style API Gateway handlers.
+
+## Install
+
+With npm:
+
+```bash
+npm install @vyriy/server
+```
+
+With Yarn:
+
+```bash
+yarn add @vyriy/server
+```
+
+## Usage
+
+Run a Lambda-style handler over HTTP:
+
+```ts
+import { server } from '@vyriy/server';
+
+server(async () => ({
+  statusCode: 200,
+  headers: {
+    'content-type': 'application/json',
+  },
+  body: JSON.stringify({ ok: true }),
+}));
+```
+
+The server listens on `PORT` from `@vyriy/env`. The default port is `3000`.

package/body.d.ts

@@ -0,0 +1,2 @@
+import type { GetBody } from './types.js';
+export declare const getBody: GetBody;

package/body.js

@@ -0,0 +1,23 @@
+import { toError } from '@vyriy/error';
+export const getBody = (request) => new Promise((resolve, reject) => {
+    const chunks = [];
+    let ended = false;
+    request
+        .on('data', (chunk) => {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    })
+        .on('end', () => {
+        ended = true;
+        if (!chunks.length) {
+            resolve(undefined);
+            return;
+        }
+        resolve(Buffer.concat(chunks).toString());
+    })
+        .on('close', () => {
+        if (!ended) {
+            reject(toError('Request body stream closed before it finished reading'));
+        }
+    })
+        .on('error', (error) => reject(toError(error)));
+});

package/index.d.ts

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

package/index.js

@@ -0,0 +1 @@
+export { server } from './server.js';

package/listen.d.ts

@@ -0,0 +1,2 @@
+import type { Listen } from './types.js';
+export declare const listen: Listen;

package/listen.js

@@ -0,0 +1,27 @@
+import { getPort } from '@vyriy/env';
+import { toError } from '@vyriy/error';
+import { logError, logListening } from './log.js';
+import { graceful } from './shutdown.js';
+export const listen = (server) => {
+    server.on('error', (error) => {
+        logError('Server error:', error);
+        process.exit(1);
+    });
+    server.on('request', (request, response) => {
+        request.on('error', (error) => {
+            logError('Request error:', toError(error));
+        });
+        response.on('error', (error) => {
+            logError('Response error:', error);
+        });
+    });
+    server.on('listening', () => {
+        const address = server.address();
+        if (address && typeof address !== 'string') {
+            logListening(address);
+        }
+    });
+    graceful(server);
+    server.listen(Number(getPort()));
+    return server;
+};

package/listener.d.ts

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

package/listener.js

@@ -0,0 +1,12 @@
+import { mapParams } from './params.js';
+import { error, result } from './result.js';
+export const listener = (handler) => async (request, response) => {
+    try {
+        const { context, event } = await mapParams(request);
+        const value = await handler(event, context);
+        result(response, value);
+    }
+    catch {
+        error(response);
+    }
+};

package/log.d.ts

@@ -0,0 +1,3 @@
+import type { AddressInfo } from 'node:net';
+export declare const logListening: (address: AddressInfo) => void;
+export declare const logError: (label: string, value: Error) => void;

package/log.js

@@ -0,0 +1,17 @@
+import { networkInterfaces } from 'node:os';
+import { createLogger } from '@vyriy/logger';
+export const logListening = (address) => {
+    const logger = createLogger();
+    Object.values(networkInterfaces())
+        .flat()
+        .forEach((details) => {
+        if (details?.family === 'IPv4') {
+            logger.warn(`http://${details.address}:${address.port}/`);
+        }
+    });
+};
+export const logError = (label, value) => {
+    const logger = createLogger();
+    logger.error(label);
+    logger.error(value);
+};

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@vyriy/server",
+  "version": "0.1.9",
+  "description": "Small HTTP server adapter for Lambda-style Vyriy handlers",
+  "type": "module",
+  "main": "./index.js",
+  "dependencies": {
+    "@types/aws-lambda": "^8.10.161",
+    "@vyriy/env": "0.1.9",
+    "@vyriy/error": "0.1.9",
+    "@vyriy/handler": "0.1.9",
+    "@vyriy/logger": "0.1.9"
+  },
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./body": {
+      "types": "./body.d.ts",
+      "import": "./body.js",
+      "default": "./body.js"
+    },
+    "./body.js": {
+      "types": "./body.d.ts",
+      "import": "./body.js",
+      "default": "./body.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./listen": {
+      "types": "./listen.d.ts",
+      "import": "./listen.js",
+      "default": "./listen.js"
+    },
+    "./listen.js": {
+      "types": "./listen.d.ts",
+      "import": "./listen.js",
+      "default": "./listen.js"
+    },
+    "./listener": {
+      "types": "./listener.d.ts",
+      "import": "./listener.js",
+      "default": "./listener.js"
+    },
+    "./listener.js": {
+      "types": "./listener.d.ts",
+      "import": "./listener.js",
+      "default": "./listener.js"
+    },
+    "./log": {
+      "types": "./log.d.ts",
+      "import": "./log.js",
+      "default": "./log.js"
+    },
+    "./log.js": {
+      "types": "./log.d.ts",
+      "import": "./log.js",
+      "default": "./log.js"
+    },
+    "./params": {
+      "types": "./params.d.ts",
+      "import": "./params.js",
+      "default": "./params.js"
+    },
+    "./params.js": {
+      "types": "./params.d.ts",
+      "import": "./params.js",
+      "default": "./params.js"
+    },
+    "./result": {
+      "types": "./result.d.ts",
+      "import": "./result.js",
+      "default": "./result.js"
+    },
+    "./result.js": {
+      "types": "./result.d.ts",
+      "import": "./result.js",
+      "default": "./result.js"
+    },
+    "./server": {
+      "types": "./server.d.ts",
+      "import": "./server.js",
+      "default": "./server.js"
+    },
+    "./server.js": {
+      "types": "./server.d.ts",
+      "import": "./server.js",
+      "default": "./server.js"
+    },
+    "./shutdown": {
+      "types": "./shutdown.d.ts",
+      "import": "./shutdown.js",
+      "default": "./shutdown.js"
+    },
+    "./shutdown.js": {
+      "types": "./shutdown.d.ts",
+      "import": "./shutdown.js",
+      "default": "./shutdown.js"
+    }
+  }
+}

package/params.d.ts

@@ -0,0 +1,3 @@
+import type { MapParams, NormalizeHeaders } from './types.js';
+export declare const normalizeHeaders: NormalizeHeaders;
+export declare const mapParams: MapParams;

package/params.js

@@ -0,0 +1,52 @@
+import { URL } from 'node:url';
+import { getBody } from './body.js';
+export const normalizeHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [
+    key,
+    Array.isArray(value) ? value.join(', ') : value,
+]));
+const mapQuery = (url) => {
+    const queryStringParameters = {};
+    const multiValueQueryStringParameters = {};
+    url.searchParams.forEach((value, key) => {
+        queryStringParameters[key] = value;
+        multiValueQueryStringParameters[key] = [...(multiValueQueryStringParameters[key] ?? []), value];
+    });
+    return { multiValueQueryStringParameters, queryStringParameters };
+};
+const createContext = () => ({
+    awsRequestId: 'local',
+    callbackWaitsForEmptyEventLoop: false,
+    done: () => undefined,
+    fail: () => undefined,
+    functionName: 'local',
+    functionVersion: '$LATEST',
+    getRemainingTimeInMillis: () => 30000,
+    invokedFunctionArn: 'local',
+    logGroupName: 'local',
+    logStreamName: 'local',
+    memoryLimitInMB: '128',
+    succeed: () => undefined,
+});
+export const mapParams = async (request) => {
+    const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
+    const { multiValueQueryStringParameters, queryStringParameters } = mapQuery(url);
+    const headers = normalizeHeaders(request.headers);
+    const body = await getBody(request);
+    return {
+        event: {
+            body: body ?? null,
+            headers,
+            httpMethod: request.method?.toUpperCase() ?? 'GET',
+            isBase64Encoded: false,
+            multiValueHeaders: Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, value ? [value] : []])),
+            multiValueQueryStringParameters,
+            path: url.pathname,
+            pathParameters: null,
+            queryStringParameters,
+            requestContext: {},
+            resource: url.pathname,
+            stageVariables: null,
+        },
+        context: createContext(),
+    };
+};

package/result.d.ts

@@ -0,0 +1,3 @@
+import type { WriteError, WriteResult } from './types.js';
+export declare const result: WriteResult;
+export declare const error: WriteError;

package/result.js

@@ -0,0 +1,24 @@
+import { STATUS_CODES } from 'node:http';
+export const result = (response, value) => {
+    if (!value) {
+        response
+            .writeHead(404, {
+            'content-type': 'application/json',
+        })
+            .end(JSON.stringify({ message: STATUS_CODES[404] }));
+        return;
+    }
+    const { body, headers, multiValueHeaders, statusCode } = value;
+    response.writeHead(statusCode, {
+        ...headers,
+        ...multiValueHeaders,
+    });
+    response.end(body);
+};
+export const error = (response) => {
+    response
+        .writeHead(500, {
+        'content-type': 'application/json',
+    })
+        .end(JSON.stringify({ message: STATUS_CODES[500] }));
+};

package/server.d.ts

@@ -0,0 +1,2 @@
+import type { CreateServer } from './types.js';
+export declare const server: CreateServer;

package/server.js

@@ -0,0 +1,4 @@
+import * as http from 'node:http';
+import { listener } from './listener.js';
+import { listen } from './listen.js';
+export const server = (handler) => listen(http.createServer(listener(handler)));

package/shutdown.d.ts

@@ -0,0 +1,5 @@
+import type { Server } from './types.js';
+type Signal = 'SIGINT' | 'SIGTERM';
+export declare const shutdown: (server: Server, signal: Signal) => void;
+export declare const graceful: (server: Server) => void;
+export {};

package/shutdown.js

@@ -0,0 +1,27 @@
+import { createLogger } from '@vyriy/logger';
+export const shutdown = (server, signal) => {
+    const logger = createLogger();
+    logger.warn(`Received ${signal}. Closing server...`);
+    server.close((error) => {
+        if (error) {
+            logger.error('Server shutdown error:');
+            logger.error(error);
+            process.exit(1);
+            return;
+        }
+        logger.warn('Server closed.');
+        process.exit(0);
+    });
+};
+export const graceful = (server) => {
+    let closing = false;
+    ['SIGINT', 'SIGTERM'].forEach((signal) => {
+        process.once(signal, () => {
+            if (closing) {
+                return;
+            }
+            closing = true;
+            shutdown(server, signal);
+        });
+    });
+};

package/types.d.ts

@@ -0,0 +1,39 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import type { Handler } from '@vyriy/handler';
+import type { IncomingHttpHeaders, OutgoingHttpHeaders, Server as HttpServer } from 'node:http';
+export type { Context } from 'aws-lambda';
+export type Headers = OutgoingHttpHeaders;
+export type LambdaEvent = APIGatewayProxyEvent;
+export type LambdaResult = APIGatewayProxyResult;
+export type LambdaHandler = Handler<LambdaEvent, LambdaResult>;
+export type RequestMessage = {
+    headers: IncomingHttpHeaders;
+    method?: string;
+    url?: string;
+    on(event: 'close', listener: () => void): RequestMessage;
+    on(event: 'data', listener: (chunk: Buffer | string) => void): RequestMessage;
+    on(event: 'end', listener: () => void): RequestMessage;
+    on(event: 'error', listener: (error: unknown) => void): RequestMessage;
+};
+export type ResponseMessage = {
+    end: {
+        (): ResponseMessage;
+        (chunk: string): ResponseMessage;
+    };
+    writeHead(statusCode: number, headers?: OutgoingHttpHeaders): ResponseMessage;
+};
+export type ErrorEventTarget = {
+    on(event: 'error', listener: (error: Error) => void): ErrorEventTarget;
+};
+export type NativeRequestListener<Request = RequestMessage, Response = ResponseMessage> = (request: Request, response: Response) => void;
+export type GetBody = (request: RequestMessage) => Promise<string | undefined>;
+export type MapParams = (request: RequestMessage) => Promise<{
+    event: LambdaEvent;
+    context: Context;
+}>;
+export type Server = HttpServer<typeof import('node:http').IncomingMessage, typeof import('node:http').ServerResponse>;
+export type Listen = (server: Server) => Server;
+export type NormalizeHeaders = (headers: IncomingHttpHeaders) => Record<string, string | undefined>;
+export type WriteResult<Response extends ResponseMessage = ResponseMessage> = (response: Response, result: LambdaResult | void) => void;
+export type WriteError<Response extends ResponseMessage = ResponseMessage> = (response: Response) => void;
+export type CreateServer = (handler: LambdaHandler) => Server;