@vyriy/server 0.2.1 → 0.3.2

package/README.md

@@ -32,4 +32,54 @@ server(async () => ({
 }));
 ```
 
+Use `api(...)` when you want the handler package wrappers. It keeps the same `(event, context)` Lambda handler shape.
+
+```ts
+import { api } from '@vyriy/handler';
+import { server } from '@vyriy/server';
+
+const handler = api(async (event) => ({
+  statusCode: 200,
+  body: JSON.stringify({
+    ok: true,
+    path: event.path,
+  }),
+}));
+
+server(handler);
+```
+
+Run a Lambda response streaming handler locally:
+
+```ts
+import { streamServer } from '@vyriy/server';
+
+streamServer(async (event, responseStream) => {
+  responseStream.setContentType?.('text/plain');
+  responseStream.write(`Path: ${event.path}\n`);
+  responseStream.end('Done');
+});
+```
+
+The stream handler receives the API Gateway-style event first, the response stream second, and the Lambda context third.
+
+Use `streamApi(...)` when you want the handler package wrappers. It keeps the same `(event, responseStream, context)` stream handler shape.
+
+```ts
+import { streamApi } from '@vyriy/handler';
+import { streamServer } from '@vyriy/server';
+
+const handler = streamApi((event, responseStream) => {
+  responseStream.setContentType?.('text/plain');
+  responseStream.write(`Path: ${event.path}\n`);
+  responseStream.end('Done');
+});
+
+streamServer(handler);
+```
+
+Keep the AWS-specific `awslambda.streamifyResponse(handler)` wrapper in a separate Lambda entrypoint.
+
+Static files are intentionally left to the Docker/web-server layer, for example Nginx, Caddy, or the platform serving assets in front of this Node process.
+
 The server listens on `PORT` from `@vyriy/env`. The default port is `3000`.

package/index.d.ts

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

package/index.js

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

package/listener.d.ts

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

package/listener.js

@@ -1,10 +1,23 @@
 import { mapParams } from './params.js';
 import { error, result } from './result.js';
+const createResponseStream = (response) => {
+    response.setContentType = (contentType) => response.setHeader?.('content-type', contentType) ?? response;
+    return response;
+};
 export const listener = (handler) => async (request, response) => {
     try {
         const { context, event } = await mapParams(request);
         const value = await handler(event, context);
-        result(response, value);
+        await result(response, value);
+    }
+    catch {
+        error(response);
+    }
+};
+export const streamListener = (handler) => async (request, response) => {
+    try {
+        const { context, event } = await mapParams(request);
+        await handler(event, createResponseStream(response), context);
     }
     catch {
         error(response);

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@vyriy/server",
-  "version": "0.2.1",
+  "version": "0.3.2",
   "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.2.1",
-    "@vyriy/error": "0.2.1",
-    "@vyriy/handler": "0.2.1",
-    "@vyriy/logger": "0.2.1"
+    "@vyriy/env": "0.3.2",
+    "@vyriy/error": "0.3.2",
+    "@vyriy/handler": "0.3.2",
+    "@vyriy/logger": "0.3.2"
   },
   "agents": "./AGENTS.md",
   "license": "MIT",

package/result.js

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

package/server.d.ts

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

package/server.js

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

package/types.d.ts

@@ -1,11 +1,12 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
-import type { Handler } from '@vyriy/handler';
+import type { ResponseStream } 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 LambdaHandler = (event: LambdaEvent, context: Context) => Promise<LambdaResult>;
+export type LambdaStreamHandler = (event: LambdaEvent, responseStream: ResponseStream, context: Context) => Promise<LambdaResult | void>;
 export type RequestMessage = {
     headers: IncomingHttpHeaders;
     method?: string;
@@ -18,8 +19,12 @@ export type RequestMessage = {
 export type ResponseMessage = {
     end: {
         (): ResponseMessage;
-        (chunk: string): ResponseMessage;
+        (chunk: string | Buffer | Uint8Array): ResponseMessage;
     };
+    writableEnded?: boolean;
+    setContentType?: (contentType: string) => ResponseMessage;
+    setHeader?(name: string, value: number | string | readonly string[]): ResponseMessage;
+    write(chunk: string | Buffer | Uint8Array): boolean;
     writeHead(statusCode: number, headers?: OutgoingHttpHeaders): ResponseMessage;
 };
 export type ErrorEventTarget = {
@@ -34,6 +39,7 @@ export type MapParams = (request: RequestMessage) => Promise<{
 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 WriteResult<Response extends ResponseMessage = ResponseMessage> = (response: Response, result: LambdaResult | void) => Promise<void> | void;
 export type WriteError<Response extends ResponseMessage = ResponseMessage> = (response: Response) => void;
 export type CreateServer = (handler: LambdaHandler) => Server;
+export type CreateStreamServer = (handler: LambdaStreamHandler) => Server;