@nextrush/adapter-edge 1.0.0-beta.0

package/src/__tests__/body-source.test.ts

@@ -0,0 +1,85 @@
+/**
+ * @nextrush/adapter-edge - Body Source Tests
+ */
+
+import { BodyConsumedError, BodyTooLargeError, EmptyBodySource as RuntimeEmptyBodySource } from '@nextrush/runtime';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createEmptyBodySource, EmptyBodySource } from '../body-source';
+
+describe('EmptyBodySource', () => {
+  let emptySource: EmptyBodySource;
+
+  beforeEach(() => {
+    emptySource = new EmptyBodySource();
+  });
+
+  it('should have contentLength of 0', () => {
+    expect(emptySource.contentLength).toBe(0);
+  });
+
+  it('should have undefined contentType', () => {
+    expect(emptySource.contentType).toBeUndefined();
+  });
+
+  it('should not be consumed', () => {
+    expect(emptySource.consumed).toBe(false);
+  });
+
+  it('should return empty string from text()', async () => {
+    const text = await emptySource.text();
+    expect(text).toBe('');
+  });
+
+  it('should return empty Uint8Array from buffer()', async () => {
+    const buffer = await emptySource.buffer();
+    expect(buffer).toBeInstanceOf(Uint8Array);
+    expect(buffer.length).toBe(0);
+  });
+
+  it('should throw BadRequestError from json()', async () => {
+    await expect(emptySource.json()).rejects.toThrow('Request body is empty');
+  });
+
+  it('should return empty ReadableStream from stream()', async () => {
+    const stream = emptySource.stream();
+    expect(stream).toBeInstanceOf(ReadableStream);
+
+    const reader = stream.getReader();
+    const { done, value } = await reader.read();
+    expect(done).toBe(true);
+    expect(value).toBeUndefined();
+  });
+});
+
+describe('BodyConsumedError', () => {
+  it('should have correct message', () => {
+    const error = new BodyConsumedError();
+    expect(error.message).toBe('Body has already been consumed');
+    expect(error.name).toBe('BodyConsumedError');
+  });
+});
+
+describe('BodyTooLargeError', () => {
+  it('should have correct message and properties', () => {
+    const error = new BodyTooLargeError(100, 200);
+
+    expect(error.message).toContain('200 bytes');
+    expect(error.message).toContain('100 bytes');
+    expect(error.name).toBe('BodyTooLargeError');
+    expect(error.limit).toBe(100);
+    expect(error.received).toBe(200);
+  });
+});
+
+describe('createEmptyBodySource', () => {
+  it('should create EmptyBodySource instance', () => {
+    const bodySource = createEmptyBodySource();
+    expect(bodySource).toBeInstanceOf(EmptyBodySource);
+  });
+});
+
+describe('F-04a — shared WebBodySource reuse', () => {
+  it('EmptyBodySource is the shared runtime EmptyBodySource', () => {
+    expect(EmptyBodySource).toBe(RuntimeEmptyBodySource);
+  });
+});

package/src/__tests__/context-response-microtrims.test.ts

@@ -0,0 +1,52 @@
+/**
+ * @nextrush/adapter-edge — HP-5-web lazy `ctx.raw` regression contract
+ *
+ * OpenSpec change `web-adapters-context-response-microtrims` (HP-5-web): the
+ * `{ req, res }` wrapper is built lazily by a memoized getter, with `req` held
+ * in a private field used by the `signal` getter and `triggerTimeout`. These
+ * are behavior-preserving characterization tests pinning the observable
+ * contract of `ctx.raw`, `ctx.signal`, and timeout across the refactor. The
+ * "no wrapper allocated when unread" proof is the allocation micro-bench
+ * (`apps/benchmark/scripts/web-context-alloc.js`, task 5.2), not a unit test.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { EdgeContext } from '../context';
+
+function makeRequest(init?: RequestInit): Request {
+  return new Request('http://localhost/', init);
+}
+
+describe('HP-5-web: Edge ctx.raw lazy memoized wrapper', () => {
+  it('returns the { req, res: undefined } shape', () => {
+    const request = makeRequest();
+    const ctx = new EdgeContext(request);
+    expect(ctx.raw.req).toBe(request);
+    expect(ctx.raw.res).toBeUndefined();
+  });
+
+  it('is memoized — repeated reads return the same object', () => {
+    const ctx = new EdgeContext(makeRequest());
+    expect(ctx.raw).toBe(ctx.raw);
+  });
+});
+
+describe('HP-5-web: Edge ctx.signal still combines request signal + timeout', () => {
+  it('aborts ctx.signal when the underlying request signal aborts', () => {
+    const controller = new AbortController();
+    const ctx = new EdgeContext(makeRequest({ signal: controller.signal }));
+    const signal = ctx.signal;
+    expect(signal).toBeInstanceOf(AbortSignal);
+    expect(signal.aborted).toBe(false);
+    controller.abort();
+    expect(signal.aborted).toBe(true);
+  });
+
+  it('aborts ctx.signal when triggerTimeout fires', () => {
+    const ctx = new EdgeContext(makeRequest());
+    const signal = ctx.signal;
+    expect(signal.aborted).toBe(false);
+    ctx.triggerTimeout();
+    expect(signal.aborted).toBe(true);
+  });
+});

package/src/__tests__/context.test.ts

@@ -0,0 +1,536 @@
+/**
+ * @nextrush/adapter-edge - Context Tests
+ *
+ * Tests for EdgeContext using Web API Request/Response.
+ * Edge runtimes (Cloudflare Workers, Vercel Edge, Netlify Edge) all use
+ * standard Web APIs, so we can test with Node.js/vitest.
+ */
+
+import { HttpError } from '@nextrush/errors';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EdgeContext, createEdgeContext, type EdgeExecutionContext } from '../context';
+
+/**
+ * Create a mock Web Request
+ */
+function createMockRequest(url: string = 'http://localhost/', init?: RequestInit): Request {
+  return new Request(url, init);
+}
+
+/**
+ * Create a mock execution context (like Cloudflare Workers)
+ */
+function createMockExecutionContext(): EdgeExecutionContext {
+  return {
+    waitUntil: vi.fn(),
+    passThroughOnException: vi.fn(),
+  };
+}
+
+describe('EdgeContext', () => {
+  let request: Request;
+  let ctx: EdgeContext;
+
+  beforeEach(() => {
+    request = createMockRequest('http://localhost/');
+    ctx = new EdgeContext(request);
+  });
+
+  describe('constructor', () => {
+    it('should create context with default values', () => {
+      expect(ctx.method).toBe('GET');
+      expect(ctx.path).toBe('/');
+      expect(ctx.status).toBe(200);
+      expect(ctx.params).toEqual({});
+      expect(ctx.body).toBeUndefined();
+      expect(ctx.runtime).toBe('edge');
+    });
+
+    it('should parse URL path', () => {
+      request = createMockRequest('http://localhost/users/123');
+      ctx = new EdgeContext(request);
+
+      expect(ctx.path).toBe('/users/123');
+      expect(ctx.url).toBe('/users/123');
+    });
+
+    it('should parse query string', () => {
+      request = createMockRequest('http://localhost/search?q=test&limit=10');
+      ctx = new EdgeContext(request);
+
+      expect(ctx.path).toBe('/search');
+      expect(ctx.query).toEqual({ q: 'test', limit: '10' });
+    });
+
+    it('should handle URL without query string', () => {
+      request = createMockRequest('http://localhost/users');
+      ctx = new EdgeContext(request);
+
+      expect(ctx.path).toBe('/users');
+      expect(ctx.query).toEqual({});
+    });
+
+    it('should get HTTP method', () => {
+      request = createMockRequest('http://localhost/', { method: 'POST' });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.method).toBe('POST');
+    });
+
+    it('should uppercase method', () => {
+      request = createMockRequest('http://localhost/', { method: 'post' });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.method).toBe('POST');
+    });
+
+    it('should extract headers', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'Content-Type': 'application/json', 'X-Custom': 'value' },
+      });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.headers['content-type']).toBe('application/json');
+      expect(ctx.headers['x-custom']).toBe('value');
+    });
+
+    it('should extract IP from cf-connecting-ip header (Cloudflare)', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'cf-connecting-ip': '192.168.1.100' },
+      });
+      ctx = new EdgeContext(request, undefined, true);
+
+      expect(ctx.ip).toBe('192.168.1.100');
+    });
+
+    it('should extract IP from x-forwarded-for header', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'x-forwarded-for': '10.0.0.1, 10.0.0.2' },
+      });
+      ctx = new EdgeContext(request, undefined, true);
+
+      expect(ctx.ip).toBe('10.0.0.1');
+    });
+
+    it('should extract IP from x-real-ip header', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'x-real-ip': '172.16.0.1' },
+      });
+      ctx = new EdgeContext(request, undefined, true);
+
+      expect(ctx.ip).toBe('172.16.0.1');
+    });
+
+    it('should not trust proxy headers when trustProxy is false', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'x-forwarded-for': '10.0.0.1', 'cf-connecting-ip': '192.168.1.100' },
+      });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.ip).toBe('');
+    });
+
+    it('should store execution context', () => {
+      const execCtx = createMockExecutionContext();
+      ctx = new EdgeContext(request, execCtx);
+
+      expect(ctx.executionContext).toBe(execCtx);
+    });
+  });
+
+  describe('json()', () => {
+    it('should build JSON response', () => {
+      ctx.json({ message: 'hello' });
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('Content-Type')).toBe('application/json; charset=utf-8');
+      expect(response.status).toBe(200);
+    });
+
+    it('should set status code', () => {
+      ctx.status = 201;
+      ctx.json({ created: true });
+
+      const response = ctx.getResponse();
+      expect(response.status).toBe(201);
+    });
+
+    it('should not send response twice', () => {
+      ctx.json({ first: true });
+      ctx.json({ second: true });
+
+      expect(ctx.responded).toBe(true);
+    });
+
+    it('should serialize data correctly', async () => {
+      ctx.json({ users: [1, 2, 3] });
+
+      const response = ctx.getResponse();
+      const body = await response.json();
+      expect(body).toEqual({ users: [1, 2, 3] });
+    });
+  });
+
+  describe('send()', () => {
+    it('should send string response', async () => {
+      ctx.send('Hello World');
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('Content-Type')).toBe('text/plain; charset=utf-8');
+
+      const text = await response.text();
+      expect(text).toBe('Hello World');
+    });
+
+    it('should send Uint8Array response', () => {
+      const buffer = new Uint8Array([72, 101, 108, 108, 111]);
+      ctx.send(buffer);
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('Content-Type')).toBe('application/octet-stream');
+    });
+
+    it('should handle null response', async () => {
+      ctx.send(null);
+
+      const response = ctx.getResponse();
+      const text = await response.text();
+      expect(text).toBe('');
+    });
+
+    it('should handle undefined response', async () => {
+      ctx.send(undefined);
+
+      const response = ctx.getResponse();
+      const text = await response.text();
+      expect(text).toBe('');
+    });
+
+    it('should send object as JSON', async () => {
+      ctx.send({ data: 'test' });
+
+      const response = ctx.getResponse();
+      const body = await response.json();
+      expect(body).toEqual({ data: 'test' });
+    });
+  });
+
+  describe('html()', () => {
+    it('should send HTML response', async () => {
+      ctx.html('<h1>Hello</h1>');
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('Content-Type')).toBe('text/html; charset=utf-8');
+
+      const text = await response.text();
+      expect(text).toBe('<h1>Hello</h1>');
+    });
+  });
+
+  describe('redirect()', () => {
+    it('should redirect with default 302 status', () => {
+      ctx.redirect('/login');
+
+      const response = ctx.getResponse();
+      expect(response.status).toBe(302);
+      expect(response.headers.get('Location')).toBe('/login');
+    });
+
+    it('should redirect with custom status', () => {
+      ctx.redirect('/new-page', 301);
+
+      const response = ctx.getResponse();
+      expect(response.status).toBe(301);
+    });
+  });
+
+  describe('set()', () => {
+    it('should set response header', () => {
+      ctx.set('X-Custom', 'value');
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('X-Custom')).toBe('value');
+    });
+
+    it('should set numeric header value', () => {
+      ctx.set('X-Count', 100);
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('X-Count')).toBe('100');
+    });
+
+    it('should accumulate multiple Set-Cookie headers', () => {
+      ctx.set('Set-Cookie', 'session=abc; Path=/');
+      ctx.set('Set-Cookie', 'csrf=xyz; Path=/');
+
+      const response = ctx.getResponse();
+      const cookies = response.headers.getSetCookie();
+      expect(cookies).toHaveLength(2);
+      expect(cookies).toContain('session=abc; Path=/');
+      expect(cookies).toContain('csrf=xyz; Path=/');
+    });
+
+    it('should replace all Set-Cookie headers when array is passed', () => {
+      ctx.set('Set-Cookie', 'old=value; Path=/');
+      ctx.set('Set-Cookie', ['new1=a; Path=/', 'new2=b; Path=/']);
+
+      const response = ctx.getResponse();
+      const cookies = response.headers.getSetCookie();
+      expect(cookies).toHaveLength(2);
+      expect(cookies).toContain('new1=a; Path=/');
+      expect(cookies).toContain('new2=b; Path=/');
+    });
+
+    it('should overwrite non-cookie headers on repeated set', () => {
+      ctx.set('X-Custom', 'first');
+      ctx.set('X-Custom', 'second');
+
+      const response = ctx.getResponse();
+      expect(response.headers.get('X-Custom')).toBe('second');
+    });
+  });
+
+  describe('get()', () => {
+    it('should get request header', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'content-type': 'application/json' },
+      });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.get('content-type')).toBe('application/json');
+    });
+
+    it('should be case-insensitive', () => {
+      request = createMockRequest('http://localhost/', {
+        headers: { 'Content-Type': 'application/json' },
+      });
+      ctx = new EdgeContext(request);
+
+      expect(ctx.get('content-type')).toBe('application/json');
+    });
+
+    it('should return undefined for missing header', () => {
+      expect(ctx.get('x-missing')).toBeUndefined();
+    });
+  });
+
+  describe('next()', () => {
+    it('should call next function when set', async () => {
+      const nextFn = vi.fn().mockResolvedValue(undefined);
+      ctx.setNext(nextFn);
+
+      await ctx.next();
+
+      expect(nextFn).toHaveBeenCalled();
+    });
+
+    it('should not throw when next is not set', async () => {
+      await expect(ctx.next()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('state', () => {
+    it('should allow storing state', () => {
+      ctx.state.user = { id: 1, name: 'John' };
+
+      expect(ctx.state.user).toEqual({ id: 1, name: 'John' });
+    });
+  });
+
+  describe('raw', () => {
+    it('should provide access to raw request', () => {
+      expect(ctx.raw.req).toBe(request);
+      expect(ctx.raw.res).toBeUndefined();
+    });
+  });
+
+  describe('responded', () => {
+    it('should be false initially', () => {
+      expect(ctx.responded).toBe(false);
+    });
+
+    it('should be true after json()', () => {
+      ctx.json({});
+      expect(ctx.responded).toBe(true);
+    });
+
+    it('should be true after send()', () => {
+      ctx.send('test');
+      expect(ctx.responded).toBe(true);
+    });
+
+    it('should be true after html()', () => {
+      ctx.html('<p>test</p>');
+      expect(ctx.responded).toBe(true);
+    });
+
+    it('should be true after redirect()', () => {
+      ctx.redirect('/');
+      expect(ctx.responded).toBe(true);
+    });
+
+    it('should be true after markResponded()', () => {
+      ctx.markResponded();
+      expect(ctx.responded).toBe(true);
+    });
+  });
+
+  describe('getResponse()', () => {
+    it('should return Response object', () => {
+      ctx.json({ test: true });
+
+      const response = ctx.getResponse();
+      expect(response).toBeInstanceOf(Response);
+    });
+
+    it('should sync status from context', () => {
+      ctx.status = 404;
+
+      const response = ctx.getResponse();
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe('waitUntil()', () => {
+    it('should call execution context waitUntil', () => {
+      const execCtx = createMockExecutionContext();
+      ctx = new EdgeContext(request, execCtx);
+
+      const promise = Promise.resolve();
+      ctx.waitUntil(promise);
+
+      expect(execCtx.waitUntil).toHaveBeenCalledWith(promise);
+    });
+
+    it('should not throw when execution context is not available', () => {
+      ctx = new EdgeContext(request);
+      const promise = Promise.resolve();
+
+      expect(() => ctx.waitUntil(promise)).not.toThrow();
+    });
+  });
+});
+
+describe('HttpError', () => {
+  it('should create error with status and message', () => {
+    const error = new HttpError(404, 'User not found');
+
+    expect(error.message).toBe('User not found');
+    expect(error.status).toBe(404);
+    expect(error.name).toBe('HttpError');
+  });
+
+  it('should use default message for status', () => {
+    const error = new HttpError(401);
+
+    expect(error.message).toBe('Unauthorized');
+    expect(error.status).toBe(401);
+  });
+
+  it('should set expose=true for client errors (4xx)', () => {
+    const error = new HttpError(400);
+    expect(error.expose).toBe(true);
+
+    const notFound = new HttpError(404);
+    expect(notFound.expose).toBe(true);
+  });
+
+  it('should set expose=false for server errors (5xx)', () => {
+    const error = new HttpError(500);
+    expect(error.expose).toBe(false);
+
+    const unavailable = new HttpError(503);
+    expect(unavailable.expose).toBe(false);
+  });
+});
+
+describe('throw()', () => {
+  let ctx: EdgeContext;
+
+  beforeEach(() => {
+    ctx = new EdgeContext(createMockRequest());
+  });
+
+  it('should throw HttpError with status and message', () => {
+    expect(() => ctx.throw(404, 'User not found')).toThrow('User not found');
+  });
+
+  it('should throw HttpError with default message', () => {
+    try {
+      ctx.throw(401);
+    } catch (error) {
+      expect((error as Error).message).toBe('Unauthorized');
+      expect((error as HttpError).status).toBe(401);
+    }
+  });
+
+  it('should throw correct status codes', () => {
+    const codes = [400, 401, 403, 404, 500, 502, 503];
+
+    for (const code of codes) {
+      try {
+        ctx.throw(code);
+      } catch (error) {
+        expect((error as HttpError).status).toBe(code);
+      }
+    }
+  });
+});
+
+describe('assert()', () => {
+  let ctx: EdgeContext;
+
+  beforeEach(() => {
+    ctx = new EdgeContext(createMockRequest());
+  });
+
+  it('should not throw when condition is truthy', () => {
+    expect(() => ctx.assert(true, 400)).not.toThrow();
+    expect(() => ctx.assert(1, 400)).not.toThrow();
+    expect(() => ctx.assert('value', 400)).not.toThrow();
+    expect(() => ctx.assert({}, 400)).not.toThrow();
+  });
+
+  it('should throw when condition is false', () => {
+    expect(() => ctx.assert(false, 400, 'Validation failed')).toThrow('Validation failed');
+  });
+
+  it('should throw when condition is null', () => {
+    expect(() => ctx.assert(null, 404, 'Not found')).toThrow('Not found');
+  });
+
+  it('should throw when condition is undefined', () => {
+    expect(() => ctx.assert(undefined, 404, 'Not found')).toThrow('Not found');
+  });
+
+  it('should use default message when not provided', () => {
+    try {
+      ctx.assert(false, 400);
+    } catch (error) {
+      expect((error as Error).message).toBe('Bad Request');
+    }
+  });
+
+  it('should narrow type with asserts', () => {
+    const maybeUser: { name: string } | null = { name: 'John' };
+    ctx.assert(maybeUser, 404, 'User not found');
+    expect(maybeUser.name).toBe('John');
+  });
+});
+
+describe('createEdgeContext', () => {
+  it('should create EdgeContext instance', () => {
+    const request = createMockRequest();
+    const ctx = createEdgeContext(request);
+
+    expect(ctx).toBeInstanceOf(EdgeContext);
+  });
+
+  it('should pass execution context', () => {
+    const request = createMockRequest();
+    const execCtx = createMockExecutionContext();
+    const ctx = createEdgeContext(request, execCtx);
+
+    expect(ctx.executionContext).toBe(execCtx);
+  });
+});