@travetto/web 6.0.0-rc.2

package/support/test/suite/standard.ts

@@ -0,0 +1,178 @@
+import assert from 'node:assert';
+
+import { Test, Suite, BeforeAll } from '@travetto/test';
+
+import { BaseWebSuite } from './base.ts';
+import { TestController } from './controller.ts';
+import { ControllerRegistry } from '../../../src/registry/controller.ts';
+
+@Suite()
+export abstract class StandardWebServerSuite extends BaseWebSuite {
+
+  @BeforeAll()
+  async init() {
+    ControllerRegistry.register(TestController);
+    await ControllerRegistry.install(TestController, { type: 'added' });
+  }
+
+  @Test()
+  async getJSON() {
+    const response = await this.request({ context: { httpMethod: 'GET', path: '/test/json' } });
+    assert.deepStrictEqual(response.body, { json: true });
+  }
+
+  @Test()
+  async getParam() {
+    const response = await this.request({ context: { httpMethod: 'POST', path: '/test/param/bob' } });
+    assert.deepStrictEqual(response.body, { param: 'bob' });
+  }
+
+  @Test()
+  async putQuery() {
+    const response = await this.request({
+      context: {
+        httpMethod: 'PUT', path: '/test/query',
+        httpQuery: {
+          age: '20'
+        }
+      }
+    });
+    assert.deepStrictEqual(response.body, { query: 20 });
+
+    await assert.rejects(() => this.request({
+      context: {
+        httpMethod: 'PUT', path: '/test/query',
+        httpQuery: {
+          age: 'blue'
+        }
+      }
+    }), /Validation errors have occurred/i);
+  }
+
+  @Test()
+  async postBody() {
+    const response = await this.request({
+      context: {
+        httpMethod: 'PUT', path: '/test/body',
+      },
+      body: {
+        age: 20
+      }
+    });
+    assert.deepStrictEqual(response.body, { body: 20 });
+  }
+
+  @Test()
+  async testCookie() {
+    const response = await this.request({
+      context: {
+        httpMethod: 'DELETE', path: '/test/cookie',
+      },
+      headers: {
+        Cookie: 'orange=yummy'
+      }
+    });
+    const [cookie] = response.headers.getSetCookie();
+    assert(cookie !== undefined);
+    assert(/flavor.*oreo/.test(cookie));
+    assert.deepStrictEqual(response.body, { cookie: 'yummy' });
+  }
+
+  @Test()
+  async testRegex() {
+    const response = await this.request({ context: { httpMethod: 'PATCH', path: '/test/regexp/super-poodle-party' } });
+    assert.deepStrictEqual(response.body, { path: 'poodle' });
+    assert(response.headers.has('ETag'));
+  }
+
+  @Test()
+  async testBuffer() {
+    const response = await this.request({ context: { httpMethod: 'GET', path: '/test/buffer' } });
+    assert(response.body === 'hello');
+    assert(response.headers.has('ETag'));
+  }
+
+  @Test()
+  async testStream() {
+    try {
+      const response = await this.request({ context: { httpMethod: 'GET', path: '/test/stream' } });
+      assert(response.body === 'hello');
+      assert(!response.headers.has('ETag'));
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  }
+
+  @Test()
+  async testRenderable() {
+    const response = await this.request({ context: { httpMethod: 'GET', path: '/test/renderable' } });
+    assert(response.body === 'hello');
+  }
+
+  @Test()
+  async testFullUrl() {
+    const response = await this.request({ context: { httpMethod: 'GET', path: '/test/fullUrl' } });
+    assert.deepStrictEqual(response.body, { path: '/test/fullUrl' });
+  }
+
+  @Test()
+  async testHeaderFirst() {
+    const response = await this.request({
+      context: {
+        httpMethod: 'GET', path: '/test/headerFirst',
+      },
+      headers: {
+        age: ['1', '2', '3']
+      }
+    });
+    assert.deepStrictEqual(response.body, { header: '1' });
+  }
+
+  @Test()
+  async testGetIp() {
+    const response = await this.request<{ ip: string | undefined }>({ context: { httpMethod: 'GET', path: '/test/ip', connection: { ip: '::1' } } });
+    assert(response.body?.ip === '127.0.0.1' || response.body?.ip === '::1');
+
+    const { body: ret2 } = await this.request<{ ip: string | undefined }>({ context: { httpMethod: 'GET', path: '/test/ip' }, headers: { 'X-Forwarded-For': 'bob' } });
+    assert(ret2?.ip === 'bob');
+  }
+
+  @Test()
+  async testErrorThrow() {
+    const { context: { httpStatusCode: statusCode } } = await this.request<{ ip: string | undefined }>({ context: { httpMethod: 'POST', path: '/test/ip' } }, false);
+    assert(statusCode === 500);
+  }
+
+  @Test()
+  async compressionReturned() {
+    {
+      const response = await this.request({ context: { httpMethod: 'GET', path: '/test/json' }, headers: { 'Accept-Encoding': 'gzip;q=1' } });
+      assert(!response.headers.has('Content-Encoding'));
+      assert.deepStrictEqual(response.body, { json: true });
+    }
+    for (const encoding of ['gzip', 'br', 'deflate']) {
+      const response = await this.request({ context: { httpMethod: 'GET', path: '/test/json/large/20000' }, headers: { 'Accept-Encoding': `${encoding};q=1` } });
+      const value = response.headers.get('Content-Encoding');
+      assert(value === encoding);
+
+      assert(response.body);
+      assert(typeof response.body === 'object');
+      assert('json' in response.body);
+      assert(typeof response.body.json === 'string');
+      assert(response.body.json.startsWith('0123456789'));
+    }
+
+    {
+      const { headers } = await this.request({ context: { httpMethod: 'GET', path: '/test/json/large/50000' }, headers: { 'Accept-Encoding': 'orange' } }, false);
+      assert(!('content-encoding' in headers));
+      // assert(status === 406);
+    }
+  }
+
+  @Test()
+  async testWildcard() {
+    const response = await this.request<{ path: string }>({ context: { httpMethod: 'GET', path: '/test/fun/1/2/3/4' } });
+    assert(response.body?.path === '1/2/3/4');
+  }
+}

package/support/transformer.web.ts

@@ -0,0 +1,207 @@
+import ts from 'typescript';
+
+import {
+  TransformerState, OnClass, OnMethod, DocUtil, DecoratorUtil, DecoratorMeta, LiteralUtil, AnyType,
+  OnProperty
+} from '@travetto/transformer';
+
+import { SchemaTransformUtil } from '@travetto/schema/support/transformer/util.ts';
+
+const PARAM_DEC_IMPORT = '@travetto/web/src/decorator/param.ts';
+const COMMON_DEC_IMPORT = '@travetto/web/src/decorator/common.ts';
+const ENDPOINT_DEC_IMPORT = '@travetto/web/src/decorator/endpoint.ts';
+
+/**
+ * Handle @Controller, @Endpoint
+ */
+export class WebTransformer {
+
+  /**
+   * Handle endpoint parameter
+   */
+  static handleEndpointParameter(state: TransformerState, node: ts.ParameterDeclaration, epDec: DecoratorMeta, idx: number): ts.ParameterDeclaration {
+    const pDec = state.findDecorator(this, node, 'Param');
+    let pDecArg = DecoratorUtil.getPrimaryArgument(pDec)!;
+    if (pDecArg && ts.isStringLiteral(pDecArg)) {
+      pDecArg = state.fromLiteral({ name: pDecArg });
+    }
+
+    const paramType = state.resolveType(node);
+    let name = node.name.getText();
+    if (/[{}\[\]]/.test(name)) { // Destructured
+      name = `param__${idx + 1}`;
+    }
+
+    let detectedParamType: string | undefined;
+
+    const config: { type: AnyType, name?: string } = { type: paramType };
+
+    // Detect default behavior
+    // If primitive
+    if (paramType.key !== 'managed' && paramType.key !== 'shape') {
+      // Get path of endpoint
+      const arg = DecoratorUtil.getPrimaryArgument(epDec.dec);
+      // If non-regex
+      if (arg && ts.isStringLiteral(arg)) {
+        const literal = LiteralUtil.toLiteral(arg);
+        if (typeof literal !== 'string') {
+          throw new Error(`Unexpected literal type: ${literal}`);
+        }
+        // If param name matches path param, default to @Path
+        detectedParamType = new RegExp(`:${name}\\b`).test(literal) ? 'PathParam' : 'QueryParam';
+      } else {
+        // Default to query for empty or regex endpoints
+        detectedParamType = 'QueryParam';
+      }
+    } else if (epDec.ident.getText() !== 'All') { // Treat all separate
+      // Treat as schema, and see if endpoint supports a body for default behavior on untyped
+      detectedParamType = epDec.targets?.includes('@travetto/web:HttpRequestBody') ? 'Body' : 'QueryParam';
+      config.name = '';
+    }
+
+    node = SchemaTransformUtil.computeField(state, node, config);
+
+    const modifiers = (node.modifiers ?? []).filter(x => x !== pDec);
+    const conf = state.extendObjectLiteral({ name, sourceText: node.name.getText() }, pDecArg);
+
+    if (!pDec) { // Handle default, missing
+      modifiers.push(state.createDecorator(PARAM_DEC_IMPORT, detectedParamType ?? 'QueryParam', conf));
+    } else if (ts.isCallExpression(pDec.expression)) { // if it does exist, update
+      modifiers.push(state.factory.createDecorator(
+        state.factory.createCallExpression(
+          pDec.expression.expression,
+          [],
+          [conf, ...pDec.expression.arguments.slice(1)]
+        )
+      ));
+    }
+
+    return state.factory.updateParameterDeclaration(
+      node,
+      modifiers,
+      node.dotDotDotToken,
+      node.name,
+      node.questionToken,
+      node.type,
+      node.initializer
+    );
+  }
+
+  /**
+   * On @Endpoint method
+   */
+  @OnMethod('Endpoint')
+  static handleEndpoint(state: TransformerState, node: ts.MethodDeclaration, dec?: DecoratorMeta): ts.MethodDeclaration {
+
+    const modifiers = (node.modifiers ?? []).slice(0);
+    const newDecls: ts.ModifierLike[] = [];
+
+    const comments = DocUtil.describeDocs(node);
+
+    // Handle description/title/summary w/e
+    if (comments.description) {
+      newDecls.push(state.createDecorator(COMMON_DEC_IMPORT, 'Describe', state.fromLiteral({
+        title: comments.description
+      })));
+    }
+
+    let nParams = node.parameters;
+
+    // Handle parameters
+    if (node.parameters.length) {
+      const params: ts.ParameterDeclaration[] = [];
+      // If there are parameters to process
+      let i = 0;
+      for (const p of node.parameters) {
+        params.push(this.handleEndpointParameter(state, p, dec!, i));
+        i += 1;
+      }
+
+      nParams = state.factory.createNodeArray(params);
+    }
+
+    // If we have a valid response type, declare it
+    const nodeType = state.resolveReturnType(node);
+    let targetType = nodeType;
+
+    if (nodeType.key === 'literal' && nodeType.typeArguments?.length && nodeType.name === 'Promise') {
+      targetType = nodeType.typeArguments[0];
+    }
+
+    let inner: AnyType | undefined;
+    if (targetType.key === 'managed' && targetType.name === 'WebResponse' && targetType.importName.startsWith('@travetto/web')) {
+      inner = state.getApparentTypeOfField(targetType.original!, 'body');
+    }
+
+    const returnType = SchemaTransformUtil.ensureType(state, inner ?? nodeType, node);
+    if (returnType.type) {
+      newDecls.push(state.createDecorator(ENDPOINT_DEC_IMPORT, 'ResponseType', state.fromLiteral({
+        ...returnType,
+        title: comments.return
+      })));
+    }
+
+    if (newDecls.length || nParams !== node.parameters) {
+      return state.factory.updateMethodDeclaration(
+        node,
+        [...modifiers, ...newDecls],
+        node.asteriskToken,
+        node.name,
+        node.questionToken,
+        node.typeParameters,
+        nParams,
+        node.type,
+        node.body
+      );
+    } else {
+      return node;
+    }
+  }
+
+  /**
+   * Handle @Controller
+   */
+  @OnClass('Controller')
+  static handleController(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    // Read title/description/summary from jsdoc on class
+    const comments = DocUtil.describeDocs(node);
+
+    if (!comments.description) {
+      return node;
+    } else {
+      return state.factory.updateClassDeclaration(
+        node,
+        [
+          ...(node.modifiers ?? []),
+          state.createDecorator(COMMON_DEC_IMPORT, 'Describe', state.fromLiteral({
+            title: comments.description
+          }))
+        ],
+        node.name,
+        node.typeParameters,
+        node.heritageClauses,
+        node.members
+      );
+    }
+  }
+
+  /**
+   * Handle ContextParam annotation
+   */
+  @OnProperty('ContextParam')
+  static registerContextParam(state: TransformerState, node: ts.PropertyDeclaration): typeof node {
+    const decl = state.findDecorator(this, node, 'ContextParam', PARAM_DEC_IMPORT);
+
+    // Doing decls
+    return state.factory.updatePropertyDeclaration(
+      node,
+      DecoratorUtil.spliceDecorators(node, decl, [
+        state.createDecorator(PARAM_DEC_IMPORT, 'ContextParam', state.fromLiteral({ target: state.getConcreteType(node) }))
+      ], 0),
+      node.name,
+      node.questionToken,
+      node.type,
+      node.initializer
+    );
+  }
+}