@travetto/web-rpc 8.0.0-alpha.2 → 8.0.0-alpha.22

package/README.md

@@ -16,21 +16,26 @@ yarn add @travetto/web-rpc
 This module allows for a highly focused scenario, of supporting RPC operations within a [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") application.  The module takes care of producing the appropriate handler for the RPC commands along with the ability to generate the appropriate client to be used to interact with the RPC functionality.  The generated client uses Proxy-based objects, along with [Typescript](https://typescriptlang.org) magic to create a dynamic client that does not rely on generating a lot of code.
 
 ## CLI - web:rpc-client
-The library will create the RPC client in one of three flavors: fetch, fetch + node, angular.
+Generate web-rpc client artifacts from a specified provider or leveraging local config.
 
-**Terminal: Command Service**
+**Terminal: Help for web:rpc-client**
 ```bash
 $ trv web:rpc-client --help
 
 Usage: web:rpc-client [options] <type:config|node|web> [output:string]
 
+Generate web-rpc client artifacts from a specified provider or leveraging local config.
+
+Resolves generator services from DI and writes typed client code for the
+selected provider target.
+
 Options:
   -p, --profile <string>  Application profiles
   -m, --module <module>   Module to run for
-  -h, --help              display help for command
+  --help                  display help for command
 ```
 
-## Example
+### Example
 
 **Code: Example Controller**
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/web-rpc",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.22",
   "type": "module",
   "description": "RPC support for a Web Application",
   "keywords": [
@@ -27,9 +27,9 @@
     "directory": "module/web-rpc"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.1",
-    "@travetto/schema": "^8.0.0-alpha.1",
-    "@travetto/web": "^8.0.0-alpha.1"
+    "@travetto/config": "^8.0.0-alpha.18",
+    "@travetto/schema": "^8.0.0-alpha.18",
+    "@travetto/web": "^8.0.0-alpha.19"
   },
   "travetto": {
     "displayName": "Web RPC Support"

package/src/controller.ts

@@ -4,7 +4,7 @@ import { IsPrivate } from '@travetto/schema';
 import {
   HeaderParam, Controller, ExcludeInterceptors, ControllerRegistryIndex,
   type WebAsyncContext, Body, EndpointUtil, BodyInterceptor, Post, WebCommonUtil,
-  RespondInterceptor, DecompressInterceptor, Get
+  RespondInterceptor, DecompressInterceptor, Get, QueryParam, Delete, Put, Patch
 } from '@travetto/web';
 
 @Controller('/rpc')
@@ -21,13 +21,28 @@ export class WebRpcController {
   ctx: WebAsyncContext;
 
   /**
-   * Allow for get-based requests
+   * Allow for extra method-based requests
    */
   @Get('/:target')
-  async onGetRequest(target: string, @HeaderParam('X-TRV-RPC-INPUTS') paramInput?: string): Promise<unknown> {
+  onGetRequest(target: string, @QueryParam('TRV_RPC_INPUTS') paramInput?: string): Promise<unknown> {
     return this.onRequest(target, paramInput);
   }
 
+  @Delete('/:target')
+  onDeleteRequest(target: string, @QueryParam('TRV_RPC_INPUTS') paramInput?: string): Promise<unknown> {
+    return this.onRequest(target, paramInput);
+  }
+
+  @Put('/:target')
+  onPutRequest(target: string, @HeaderParam('X-TRV-RPC-INPUTS') paramInput?: string, @Body() body?: Any): Promise<unknown> {
+    return this.onRequest(target, paramInput, body);
+  }
+
+  @Patch('/:target')
+  onPatchRequest(target: string, @HeaderParam('X-TRV-RPC-INPUTS') paramInput?: string, @Body() body?: Any): Promise<unknown> {
+    return this.onRequest(target, paramInput, body);
+  }
+
   /**
    * RPC main entrypoint
    */

package/support/cli.web_rpc-client.ts

@@ -10,7 +10,10 @@ import type { WebRpcClient } from '../src/config.ts';
 import { WebRpcClientGeneratorService } from '../src/service.ts';
 
 /**
- * Generate the web-rpc client
+ * Generate web-rpc client artifacts from a specified provider or leveraging local config.
+ *
+ * Resolves generator services from DI and writes typed client code for the
+ * selected provider target.
  */
 @CliCommand()
 export class CliWebRpcCommand implements CliCommandShape {

package/support/client/rpc.ts

@@ -3,13 +3,32 @@ type MethodKeys<C extends {}> = {
 }[keyof C];
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type PromiseFn = (...args: any) => Promise<unknown>;
-type PromiseRes<V extends PromiseFn> = Awaited<ReturnType<V>>;
+type PromiseResult<V extends PromiseFn> = Awaited<ReturnType<V>>;
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isBlobMap = (value: any): value is Record<string, Blob> => value && typeof value === 'object' && value[Object.keys(value)[0]] instanceof Blob;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isBlobLike = (value: any): value is Record<string, Blob> | Blob => value instanceof Blob || isBlobMap(value);
+const triggerBrowserRedirect = (world: any, url: URL): boolean => {
+  const location = world?.window?.location;
+  if (location) {
+    location.href = url.toString();
+    return true;
+  }
+  return false;
+};
+
+const isBlobMap = (value: unknown): value is Record<string, Blob> => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  for (const [key, item] of Object.entries(value)) {
+    if (!(item instanceof Blob) || typeof key !== 'string') {
+      return false;
+    }
+  }
+  return true;
+};
+
+const isBlobLike = (value: unknown): value is Record<string, Blob> | Blob => value instanceof Blob || isBlobMap(value);
 
 const extendHeaders = (base: RequestInit['headers'], toAdd: Record<string, string>): Headers => {
   const headers = new Headers(base);
@@ -18,10 +37,10 @@ const extendHeaders = (base: RequestInit['headers'], toAdd: Record<string, strin
 };
 
 const jsonToString = (input: unknown): string =>
-  JSON.stringify(input, (key, value): unknown => typeof value === 'bigint' ? `${value.toString()}n` : value);
+  JSON.stringify(input, (_, value): unknown => typeof value === 'bigint' ? `${value.toString()}n` : value);
 
 const stringToJson = <T = unknown>(input: string): T =>
-  JSON.parse(input, (key, value): unknown => {
+  JSON.parse(input, (_, value): unknown => {
     if (typeof value === 'string') {
       if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[.]\d{3}Z$/.test(value)) {
         return new Date(value);
@@ -33,16 +52,18 @@ const stringToJson = <T = unknown>(input: string): T =>
   });
 
 
-export type PreRequestHandler = (item: RequestInit) => Promise<RequestInit | undefined | void>;
+export type PreRequestHandler = (item: RequestInit) => Promise<RpcRequest['core'] | undefined | void>;
 export type PostResponseHandler = (item: Response) => Promise<Response | undefined | void>;
 
 export type RpcRequest = {
-  core?: Partial<RequestInit> & {
+  core: Omit<Partial<RequestInit>, 'method'> & {
     timeout?: number;
     retriesOnConnectFailure?: number;
-    path?: string;
-    controller?: string;
-    endpoint?: string;
+    path: string;
+    controller: string;
+    endpoint: string;
+    method: string;
+    browserRedirect?: boolean;
   };
   url: URL | string;
   consumeJSON?: <T>(text?: unknown) => (T | Promise<T>);
@@ -57,7 +78,7 @@ export type RpcClient<T extends Record<string, {}>, E extends Record<string, Fun
 
 export type RpcClientFactory<T extends Record<string, {}>> =
   <R extends Record<string, Function>>(
-    baseOpts: RpcRequest,
+    baseOpts: Omit<Partial<RpcRequest>, 'url'> & { url: RpcRequest['url'] },
     decorate?: (request: RpcRequest) => R
   ) => RpcClient<T, R>;
 
@@ -87,28 +108,49 @@ function registerTimeout<T>(
 }
 
 function buildRequest<T extends RequestInit>(base: T, controller: string, endpoint: string): T {
+  let verb: string;
+  switch (endpoint.split(/[A-Z]/)[0]) {
+    case 'get': verb = 'GET'; break;
+    case 'update': verb = 'PUT'; break;
+    case 'delete': verb = 'DELETE'; break;
+    case 'create': default: verb = 'POST'; break;
+  }
   return {
     ...base,
-    method: 'POST',
+    method: verb,
     path: `${controller}:${endpoint}`,
     controller,
     endpoint
   };
 }
 
-export function getBody(inputs: unknown[], isBodyRequest: boolean): { body: FormData | string | undefined, headers: Record<string, string> } {
-  if (!isBodyRequest) {
-    return {
-      body: undefined,
-      headers: {
-        'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(jsonToString(inputs)))
-      }
-    };
+export function getBody(inputs: unknown[], method: string): {
+  body: FormData | string | undefined;
+  query: Record<string, string> | undefined;
+  method: string;
+  headers: Record<string, string>;
+} {
+  let outMethod = method;
+  if (method.toLowerCase() === 'get' || method.toLowerCase() === 'delete') {
+    const inputComputed = btoa(encodeURIComponent(jsonToString(inputs)));
+    if (inputComputed.length < 1000) {
+      return {
+        body: undefined,
+        method: outMethod,
+        query: { TRV_RPC_INPUTS: inputComputed },
+        headers: {}
+      };
+    } else {
+      outMethod = 'POST';
+    }
   }
+
   // If we do not have a blob, simple output
   if (!inputs.some(isBlobLike)) {
     return {
       body: jsonToString(inputs),
+      query: undefined,
+      method: outMethod,
       headers: {
         'Content-Type': 'application/json'
       }
@@ -130,6 +172,8 @@ export function getBody(inputs: unknown[], isBodyRequest: boolean): { body: Form
 
   return {
     body: form,
+    query: undefined,
+    method: outMethod,
     headers: {
       'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(jsonToString(plainInputs)))
     }
@@ -169,20 +213,16 @@ export async function consumeError(error: unknown): Promise<Error> {
 }
 
 export async function invokeFetch<T>(request: RpcRequest, ...params: unknown[]): Promise<T> {
-  let core = request.core!;
+  let core = { ...request.core };
 
   try {
-    const { body, headers } = getBody(params, /^(post|put|patch)$/i.test(request.core?.method ?? 'POST'));
-    if (body) {
-      core.body = body;
-    }
+    const { method, body, headers, query } = getBody(params, request.core.method);
+    if (body) { core.body = body; }
+    core.method = method;
     core.headers = extendHeaders(core.headers, headers);
 
     for (const fn of request.preRequestHandlers ?? []) {
-      const computed = await fn(core);
-      if (computed) {
-        core = computed;
-      }
+      core = (await fn(core)) ?? core;
     }
 
     const signals = [];
@@ -202,8 +242,13 @@ export async function invokeFetch<T>(request: RpcRequest, ...params: unknown[]):
     }
 
     const url = typeof request.url === 'string' ? new URL(request.url) : request.url;
-    if (request.core?.path) {
-      url.pathname = `${url.pathname}/${request.core.path}`.replaceAll('//', '/');
+    url.pathname = `${url.pathname}/${request.core.path || '/'}`.replaceAll('//', '/');
+    for (const [key, value] of Object.entries(query ?? {})) {
+      url.searchParams.append(key, value);
+    }
+
+    if (core.browserRedirect && triggerBrowserRedirect(globalThis, url)) {
+      return Promise.resolve(undefined!);
     }
 
     let resolved: Response | undefined;
@@ -265,7 +310,12 @@ export function clientFactory<T extends Record<string, {}>>(): RpcClientFactory<
       consumeJSON,
       consumeError,
       ...request,
-      core: { timeout: 0, credentials: 'include', mode: 'cors', ...request.core },
+      core: {
+        method: 'POST',
+        path: undefined!, controller: undefined!, endpoint: undefined!,
+        timeout: 0, credentials: 'include', mode: 'cors',
+        ...request.core
+      },
     };
     const cache: Record<string, unknown> = {};
     // @ts-ignore
@@ -292,7 +342,7 @@ export function clientFactory<T extends Record<string, {}>>(): RpcClientFactory<
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function withConfigFactoryDecorator(request: RpcRequest) {
   return {
-    withConfig<V extends PromiseFn>(this: V, extra: Partial<RpcRequest['core']>, ...params: Parameters<V>): Promise<PromiseRes<V>> {
+    withConfig<V extends PromiseFn>(this: V, extra: Partial<RpcRequest['core']>, ...params: Parameters<V>): Promise<PromiseResult<V>> {
       return invokeFetch({ ...request, core: { ...request.core, ...extra } }, ...params);
     }
   };