@travetto/web 6.0.0-rc.2

package/support/test/dispatch-util.ts

@@ -0,0 +1,90 @@
+import { buffer as toBuffer } from 'node:stream/consumers';
+
+import { AppError, BinaryUtil, castTo } from '@travetto/runtime';
+import { BindUtil } from '@travetto/schema';
+
+import { WebResponse } from '../../src/types/response.ts';
+import { WebRequest } from '../../src/types/request.ts';
+import { DecompressInterceptor } from '../../src/interceptor/decompress.ts';
+import { WebBodyUtil } from '../../src/util/body.ts';
+import { WebCommonUtil } from '../../src/util/common.ts';
+
+/**
+ * Utilities for supporting custom test dispatchers
+ */
+export class WebTestDispatchUtil {
+
+  static async applyRequestBody(request: WebRequest): Promise<WebRequest> {
+    if (request.body !== undefined) {
+      const sample = WebBodyUtil.toBinaryMessage(request);
+      sample.headers.forEach((v, k) => request.headers.set(k, Array.isArray(v) ? v.join(',') : v));
+      request.body = WebBodyUtil.markRaw(await WebBodyUtil.toBuffer(sample.body!));
+    }
+    Object.assign(request.context, { httpQuery: BindUtil.flattenPaths(request.context.httpQuery ?? {}) });
+    return request;
+  }
+
+  static async finalizeResponseBody(response: WebResponse, decompress?: boolean): Promise<WebResponse> {
+    let result = response.body;
+
+    response.context.httpStatusCode = WebCommonUtil.getStatusCode(response);
+
+    if (decompress) {
+      if (Buffer.isBuffer(result) || BinaryUtil.isReadable(result)) {
+        const bufferResult = result = await WebBodyUtil.toBuffer(result);
+        if (bufferResult.length) {
+          try {
+            result = await DecompressInterceptor.decompress(
+              response.headers,
+              bufferResult,
+              { applies: true, supportedEncodings: ['br', 'deflate', 'gzip', 'identity'] }
+            );
+          } catch { }
+        }
+      }
+    }
+
+    const text = Buffer.isBuffer(result) ? result.toString('utf8') : (typeof result === 'string' ? result : undefined);
+
+    if (text) {
+      switch (response.headers.get('Content-Type')) {
+        case 'application/json': result = JSON.parse(castTo(text)); break;
+        case 'text/plain': result = text; break;
+      }
+    }
+
+    if (response.context.httpStatusCode && response.context.httpStatusCode >= 400) {
+      result = WebCommonUtil.catchResponse(AppError.fromJSON(result) ?? result).body;
+    }
+
+    response.body = result;
+    return response;
+  }
+
+  static async toFetchRequestInit(request: WebRequest): Promise<{ init: RequestInit, path: string }> {
+    const { context: { httpQuery: query, httpMethod: method, path }, headers } = request;
+
+    let q = '';
+    if (query && Object.keys(query).length) {
+      const pairs = Object.fromEntries(Object.entries(query).map(([k, v]) => [k, v === null || v === undefined ? '' : `${v}`] as const));
+      q = `?${new URLSearchParams(pairs).toString()}`;
+    }
+
+    const finalPath = `${path}${q}`;
+
+    const body: RequestInit['body'] =
+      WebBodyUtil.isRaw(request.body) ?
+        Buffer.isBuffer(request.body) ? request.body : await toBuffer(request.body) :
+        castTo(request.body);
+
+    return { path: finalPath, init: { headers, method, body } };
+  }
+
+  static async fromFetchResponse(response: Response): Promise<WebResponse> {
+    return new WebResponse({
+      body: Buffer.from(await response.arrayBuffer()),
+      context: { httpStatusCode: response.status },
+      headers: response.headers
+    });
+  }
+}

package/support/test/dispatcher.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@travetto/di';
+
+import type { WebFilterContext } from '../../src/types/filter.ts';
+import { WebResponse } from '../../src/types/response.ts';
+import { StandardWebRouter } from '../../src/router/standard.ts';
+import { WebTestDispatchUtil } from './dispatch-util.ts';
+
+@Injectable()
+export class LocalRequestDispatcher extends StandardWebRouter {
+  async dispatch({ request }: WebFilterContext): Promise<WebResponse> {
+    const resolved = await WebTestDispatchUtil.applyRequestBody(request);
+    const res = await super.dispatch({ request: resolved });
+    return WebTestDispatchUtil.finalizeResponseBody(res, true);
+  }
+}

package/support/test/suite/base.ts

@@ -0,0 +1,61 @@
+import { RootRegistry } from '@travetto/registry';
+import { castTo, Class } from '@travetto/runtime';
+import { AfterAll, BeforeAll } from '@travetto/test';
+import { DependencyRegistry, Injectable } from '@travetto/di';
+import { ConfigSource, ConfigSpec } from '@travetto/config';
+
+import { WebDispatcher } from '../../../src/types/dispatch.ts';
+import { WebRequest, WebRequestContext } from '../../../src/types/request.ts';
+import { WebResponse } from '../../../src/types/response.ts';
+import { WebMessageInit } from '../../../src/types/message.ts';
+
+@Injectable()
+export class WebTestConfig implements ConfigSource {
+  async get(): Promise<ConfigSpec> {
+    return {
+      data: {
+        web: {
+          cookie: { secure: false },
+          trustProxy: { ips: ['*'] },
+          http: {
+            ssl: { active: false },
+            port: -1,
+          }
+        }
+      },
+      source: 'custom://test/web',
+      priority: 10000
+    };
+  }
+}
+
+/**
+ * Base Web Suite
+ */
+export abstract class BaseWebSuite {
+
+  #cleanup?: () => void;
+  #dispatcher: WebDispatcher;
+
+  serve?(): Promise<() => void>;
+  dispatcherType: Class<WebDispatcher>;
+
+  @BeforeAll()
+  async initServer(): Promise<void> {
+    await RootRegistry.init();
+    this.#cleanup = await this.serve?.();
+    this.#dispatcher = await DependencyRegistry.getInstance(this.dispatcherType);
+  }
+
+  @AfterAll()
+  async destroySever(): Promise<void> {
+    await this.#cleanup?.();
+    this.#cleanup = undefined;
+  }
+
+  async request<T>(cfg: WebMessageInit<unknown, WebRequestContext>, throwOnError: boolean = true): Promise<WebResponse<T>> {
+    const response = await this.#dispatcher.dispatch({ request: new WebRequest(cfg) });
+    if (throwOnError && response.context.httpStatusCode && response.context.httpStatusCode >= 400) { throw response.body; }
+    return castTo(response);
+  }
+}

package/support/test/suite/controller.ts

@@ -0,0 +1,103 @@
+import { Readable } from 'node:stream';
+
+import { AppError, castTo } from '@travetto/runtime';
+
+import { Controller } from '../../../src/decorator/controller.ts';
+import { Get, Post, Put, Delete, Patch } from '../../../src/decorator/endpoint.ts';
+import { ContextParam, PathParam, QueryParam } from '../../../src/decorator/param.ts';
+import { Produces, SetHeaders } from '../../../src/decorator/common.ts';
+
+import { WebRequest } from '../../../src/types/request.ts';
+import { WebResponse } from '../../../src/types/response.ts';
+import { CookieJar } from '../../../src/util/cookie.ts';
+
+@Controller('/test')
+export class TestController {
+
+  @ContextParam()
+  request: WebRequest;
+
+  @ContextParam()
+  cookies: CookieJar;
+
+  @Get('/json')
+  getJSON() {
+    return { json: true };
+  }
+
+  @Get('/json/large/:size')
+  getJSONLarge(size = 20000) {
+    return { json: '0123456789'.repeat(size / 10) };
+  }
+
+  @Post('/param/:param')
+  withParam(@PathParam() param: string) {
+    return { param };
+  }
+
+  @Put('/query')
+  withQuery(@QueryParam() age: number) {
+    return { query: age };
+  }
+
+  @Put('/body')
+  withBody() {
+    return { body: castTo<{ age: number }>(this.request.body).age };
+  }
+
+  @Delete('/cookie')
+  withCookie() {
+    this.cookies.set({ name: 'flavor', value: 'oreo' });
+    return new WebResponse({ body: { cookie: this.cookies.get('orange') } });
+  }
+
+  @Patch('/regexp/super-:special-party')
+  withRegexp(@PathParam() special: string) {
+    return { path: special };
+  }
+
+  @Get('/stream')
+  @SetHeaders({ 'Content-Type': 'text/plain' })
+  getStream() {
+    return Readable.from(Buffer.from('hello'));
+  }
+
+  @Get('/buffer')
+  @Produces('text/plain')
+  getBuffer() {
+    return Buffer.from('hello');
+  }
+
+  @Get('/renderable')
+  @Produces('text/plain')
+  getRenderable(): WebResponse<string> {
+    return new WebResponse({ body: 'hello' });
+  }
+
+  @Get('/fullUrl')
+  getFullUrl() {
+    return {
+      path: this.request.context.path
+    };
+  }
+
+  @Get('/headerFirst')
+  getHeaderFirst() {
+    return { header: this.request.headers.get('Age')?.split(',')?.[0] };
+  }
+
+  @Get('/fun/*')
+  getFun() {
+    return { path: this.request.context.path.split('fun/')[1] };
+  }
+
+  @Get('/ip')
+  getIp() {
+    return { ip: this.request.context.connection?.ip };
+  }
+
+  @Post('/ip')
+  notFound() {
+    throw new AppError('Uh-oh', { category: 'general' });
+  }
+}

package/support/test/suite/schema.ts

@@ -0,0 +1,275 @@
+import assert from 'node:assert';
+
+import { Suite, Test } from '@travetto/test';
+import { Schema, SchemaRegistry, ValidationResultError, Validator } from '@travetto/schema';
+import { Controller, Post, Get, ControllerRegistry, WebResponse, PathParam, QueryParam, HttpMethod } from '@travetto/web';
+
+import { BaseWebSuite } from './base.ts';
+
+interface UserShape {
+  id: number | undefined;
+  age: number;
+  name: string;
+  active: boolean;
+}
+
+@Schema()
+class SimpleUser {
+  id: number;
+  age: number;
+  name: string;
+  active: boolean;
+}
+
+@Validator(user => {
+  if (user && user.age === 300) {
+    return { kind: 'value', message: 'Age cannot be 300', path: 'age' };
+  }
+})
+@Schema()
+class User {
+  id: number = -1;
+  name: string;
+  age: number;
+  active: boolean;
+}
+
+async function getUser(x: number) {
+  return User.from({});
+}
+
+@Controller('/test/schema')
+class SchemaAPI {
+  @Post('/user')
+  async saveUser(user: User) {
+    return user;
+  }
+
+  @Get('/user')
+  async queryUser(user: User) {
+    return user;
+  }
+
+  @Get('/interface')
+  async ifUser(user: UserShape) {
+    return user;
+  }
+
+  @Get('/interface-prefix')
+  async ifUserPrefix(user: User, @QueryParam({ prefix: 'user2' }) user3: User) {
+    return user;
+  }
+
+  @Get('/void')
+  async voidUser() {
+    return Promise.resolve((() => { })());
+  }
+
+  @Get('/voidAll')
+  async voidAllUser() {
+    return Promise.resolve([1, 2, 3].map(() => { }));
+  }
+
+  @Get('/users')
+  async allUsers() {
+    return Promise.all([1, 2, 3,].map(x => getUser(x)));
+  }
+
+  @Get('/allShapes')
+  async allShape() {
+    return Promise.all([1, 2, 3,].map(async x => ({ key: x, count: 5 })));
+  }
+
+  @Get('/classShape/:shape')
+  async classShape(@PathParam('shape') sh: string) {
+    return new SimpleUser();
+  }
+
+  @Get('/renderable/:age')
+  async renderable(age: number) {
+    return WebResponse.redirect('google.com');
+  }
+
+  @Get('/customSerialize')
+  async customSerialize() {
+    return new WebResponse({ body: new User() });
+  }
+
+  /**
+   * @returns {Promise<User>}
+   */
+  @Get('/customSerialize2')
+  async customSerialize2() {
+  }
+}
+
+function getEndpoint(path: string, method: HttpMethod) {
+  return ControllerRegistry.get(SchemaAPI)
+    .endpoints.find(x => x.path === path && x.httpMethod === method)!;
+}
+
+@Suite()
+export abstract class SchemaWebServerSuite extends BaseWebSuite {
+
+  @Test()
+  async verifyBody() {
+    const user = { id: '0', name: 'bob', age: '20', active: 'false' };
+
+    const response1 = await this.request<UserShape>({ context: { httpMethod: 'POST', path: '/test/schema/user' }, body: user });
+
+    assert(response1.body?.name === user.name);
+
+    const response2 = await this.request<ValidationResultError>({ context: { httpMethod: 'POST', path: '/test/schema/user' }, body: { id: 'orange' } }, false);
+
+    assert(response2.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response2.body?.message ?? ''));
+    assert(response2.body?.details.errors[0].path === 'id');
+
+    const response3 = await this.request<ValidationResultError>({ context: { httpMethod: 'POST', path: '/test/schema/user' }, body: { id: 0, name: 'bob', age: 'a' } }, false);
+
+    assert(response3.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response3.body?.message ?? ''));
+    assert(response3.body?.details.errors[0].path === 'age');
+  }
+
+  @Test()
+  async verifyQuery() {
+    const user = { id: '0', name: 'bob', age: '20', active: 'false' };
+
+    const response1 = await this.request<UserShape>({ context: { httpMethod: 'GET', path: '/test/schema/user', httpQuery: user } });
+
+    assert(response1.body?.name === user.name);
+
+    const response2 = await this.request<ValidationResultError>({ context: { httpMethod: 'GET', path: '/test/schema/user', httpQuery: { id: 'orange' } } }, false);
+
+    assert(response2.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response2.body?.message ?? ''));
+    assert(response2.body?.details.errors[0].path === 'id');
+
+    const response3 = await this.request<ValidationResultError>({
+      context: {
+        httpMethod: 'GET',
+        path: '/test/schema/user',
+        httpQuery: { id: '0', name: 'bob', age: 'a' }
+      }
+    }, false);
+
+    assert(response3.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response3.body?.message ?? ''));
+    assert(response3.body?.details.errors[0].path === 'age');
+  }
+
+  @Test()
+  async verifyInterface() {
+    const user = { id: '0', name: 'bob', age: '20', active: 'false' };
+
+    const response1 = await this.request<UserShape>({ context: { httpMethod: 'GET', path: '/test/schema/interface', httpQuery: user } });
+
+    assert(response1.body?.name === user.name);
+    assert(response1.body?.age === 20);
+
+    const response2 = await this.request<ValidationResultError>({ context: { httpMethod: 'GET', path: '/test/schema/interface', httpQuery: { id: 'orange' } } }, false);
+
+    assert(response2.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response2.body?.message ?? ''));
+    assert(response2.body?.details.errors[0].path === 'id');
+
+    const response3 = await this.request<ValidationResultError>({
+      context: {
+        httpMethod: 'GET',
+        path: '/test/schema/interface',
+        httpQuery: { id: '0', name: 'bob', age: 'a' }
+      }
+    }, false);
+
+    assert(response3.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response3.body?.message ?? ''));
+    assert(response3.body?.details.errors[0].path === 'age');
+  }
+
+  @Test()
+  async verifyPrefix() {
+    const user = { id: '0', name: 'bob', age: '20', active: 'false' };
+
+    const response1 = await this.request<ValidationResultError>({ context: { httpMethod: 'GET', path: '/test/schema/interface-prefix', httpQuery: user, } }, false);
+
+    assert(response1.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response1.body?.message ?? ''));
+    console.error(response1.body);
+    assert(response1.body?.details.errors[0].path.startsWith('user2'));
+
+    const response2 = await this.request<ValidationResultError>({ context: { httpMethod: 'GET', path: '/test/schema/interface-prefix', httpQuery: { user3: user } } }, false);
+
+    assert(response2.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response2.body?.message ?? ''));
+    assert(response2.body?.details.errors[0].path);
+    assert(!response2.body?.details.errors[0].path.startsWith('user'));
+
+    const response3 = await this.request<User>({ context: { httpMethod: 'GET', path: '/test/schema/interface-prefix', httpQuery: { ...user, user2: user } } });
+
+    assert(response3.context.httpStatusCode === 200);
+    assert(response3.body?.name === user.name);
+    assert(response3.body?.age === 20);
+
+    const response4 = await this.request<ValidationResultError>({
+      context: {
+        httpMethod: 'GET', path: '/test/schema/interface-prefix',
+        httpQuery: { ...user, user2: { ...user, age: '300' } }
+      }
+    }, false);
+
+    assert(response4.context.httpStatusCode === 400);
+    assert(/Validation errors have occurred/.test(response4.body?.message ?? ''));
+    assert(response4.body?.details.errors[0].path);
+    assert(!response4.body?.details.errors[0].path.startsWith('user2.age'));
+  }
+
+  @Test()
+  async verifyVoid() {
+    const ep = getEndpoint('/void', 'GET');
+    assert(ep.responseType === undefined);
+  }
+
+  @Test()
+  async verifyVoidAll() {
+    const ep = getEndpoint('/voidAll', 'GET');
+    assert(ep.responseType === undefined);
+  }
+
+  @Test()
+  async verifyList() {
+    const ep = getEndpoint('/users', 'GET');
+    assert(ep.responseType?.type === User);
+  }
+
+  @Test()
+  async verifyShapeAll() {
+    const ep = getEndpoint('/allShapes', 'GET');
+    console.log(`${ep.responseType}`);
+  }
+
+  @Test()
+  async verifyShapeClass() {
+    const ep = getEndpoint('/classShape/:shape', 'GET');
+    assert(ep.responseType);
+    assert(SchemaRegistry.has(ep.responseType!.type));
+  }
+
+  @Test()
+  async verifyRenderable() {
+    const ep = getEndpoint('/renderable/:age', 'GET');
+    assert(ep.responseType?.type === undefined);
+  }
+
+  @Test()
+  async verifyCustomSerializeable() {
+    const ep = getEndpoint('/customSerialize', 'GET');
+    assert(ep.responseType?.type === User);
+  }
+
+  @Test()
+  async verifyCustomSerializeable2() {
+    const ep = getEndpoint('/customSerialize2', 'GET');
+    assert(ep.responseType?.type === User);
+  }
+}