@travetto/web-rpc 7.1.4 → 8.0.0-alpha.1

package/package.json

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

package/src/controller.ts

@@ -1,5 +1,5 @@
 import { Inject } from '@travetto/di';
-import { type Any, AppError, JSONUtil } from '@travetto/runtime';
+import { type Any, RuntimeError, JSONUtil } from '@travetto/runtime';
 import { IsPrivate } from '@travetto/schema';
 import {
   HeaderParam, Controller, ExcludeInterceptors, ControllerRegistryIndex,
@@ -36,7 +36,7 @@ export class WebRpcController {
     const endpoint = ControllerRegistryIndex.getEndpointConfigById(target);
 
     if (!endpoint || !endpoint.filter) {
-      throw new AppError('Unknown endpoint', { category: 'notfound' });
+      throw new RuntimeError('Unknown endpoint', { category: 'notfound' });
     }
 
     const { request } = this.ctx;
@@ -45,7 +45,7 @@ export class WebRpcController {
 
     // Allow request to read inputs from header
     if (paramInput) {
-      params = JSONUtil.parseBase64(paramInput)!;
+      params = JSONUtil.fromBase64(paramInput);
     } else if (Array.isArray(body)) { // Params passed via body
       params = body;
 
@@ -54,7 +54,7 @@ export class WebRpcController {
         request.body = params[bodyParamIdx];
       }
     } else if (body) {
-      throw new AppError('Invalid parameters, must be an array', { category: 'data' });
+      throw new RuntimeError('Invalid parameters, must be an array', { category: 'data' });
     } else {
       params = [];
     }

package/src/service.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 
-import { Inject, Injectable } from '@travetto/di';
+import { Inject, Injectable, PostConstruct } from '@travetto/di';
 import { ControllerRegistryIndex } from '@travetto/web';
 import { Runtime, RuntimeIndex } from '@travetto/runtime';
 import { ManifestModuleUtil } from '@travetto/manifest';
@@ -16,7 +16,8 @@ export class WebRpcClientGeneratorService {
   @Inject()
   config: WebRpcConfig;
 
-  async postConstruct(): Promise<void> {
+  @PostConstruct()
+  async initialRender(): Promise<void> {
     this.render();
   }
 

package/support/cli.web_rpc-client.ts

@@ -1,10 +1,9 @@
 import path from 'node:path';
 
 import { Env } from '@travetto/runtime';
-import { CliCommand, type CliCommandShape, CliValidationResultError } from '@travetto/cli';
+import { CliCommand, type CliCommandShape, CliModuleFlag, CliProfilesFlag, CliValidationResultError } from '@travetto/cli';
 import { DependencyRegistryIndex } from '@travetto/di';
 import { Registry } from '@travetto/registry';
-import { Ignore } from '@travetto/schema';
 
 import type { WebRpcClient } from '../src/config.ts';
 import { WebRpcClientGeneratorService } from '../src/service.ts';
@@ -12,13 +11,16 @@ import { WebRpcClientGeneratorService } from '../src/service.ts';
 /**
  * Generate the web-rpc client
  */
-@CliCommand({ with: { profiles: true, module: true } })
+@CliCommand()
 export class CliWebRpcCommand implements CliCommandShape {
 
-  @Ignore()
+  @CliProfilesFlag()
+  profile: string[];
+
+  @CliModuleFlag({ short: 'm' })
   module: string;
 
-  preMain(): void {
+  finalize(): void {
     Env.DEBUG.set(false);
   }
 
@@ -33,7 +35,7 @@ export class CliWebRpcCommand implements CliCommandShape {
     } else {
       if (!output) {
         throw new CliValidationResultError(this, [
-          { message: 'output is required when type is not `config`', source: 'arg' }
+          { message: 'output is required when type is not `config`', source: 'arg', kind: 'missing', path: 'output' }
         ]);
       }
       output = path.resolve(output);

package/support/client/rpc-node.ts

@@ -2,11 +2,9 @@ import { consumeError } from './rpc.ts';
 
 export async function toNodeError(payload: unknown): Promise<Error> {
   try {
-    let result = undefined;
-    const { AppError } = await import('@travetto/runtime');
-    result = AppError.fromJSON(payload);
-    if (result) {
-      return result;
+    const { JSONUtil } = await import('@travetto/runtime');
+    if (JSONUtil.isJSONError(payload)) {
+      return JSONUtil.jsonErrorToError(payload);
     }
   } catch { }
   return consumeError(payload);

package/support/client/rpc.ts

@@ -17,6 +17,22 @@ const extendHeaders = (base: RequestInit['headers'], toAdd: Record<string, strin
   return headers;
 };
 
+const jsonToString = (input: unknown): string =>
+  JSON.stringify(input, (key, value): unknown => typeof value === 'bigint' ? `${value.toString()}n` : value);
+
+const stringToJson = <T = unknown>(input: string): T =>
+  JSON.parse(input, (key, 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);
+      } else if (/^-?d+n$/.test(value)) {
+        return BigInt(value.slice(0, -1));
+      }
+    }
+    return value;
+  });
+
+
 export type PreRequestHandler = (item: RequestInit) => Promise<RequestInit | undefined | void>;
 export type PostResponseHandler = (item: Response) => Promise<Response | undefined | void>;
 
@@ -57,14 +73,14 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
     && Object.prototype.toString.call(value) === '[object Object]'; // separate build-in like Math
 }
 
-function registerTimeout<T extends (number | string | { unref(): unknown })>(
+function registerTimeout<T>(
   controller: AbortController,
   timeout: number,
   start: (fn: (...args: unknown[]) => unknown, delay: number) => T,
   stop: (value: T) => void
 ): void {
   const timer = start(() => controller.abort(), timeout);
-  if (!(typeof timer === 'number' || typeof timer === 'string')) {
+  if (timer && typeof timer === 'object' && 'unref' in timer && typeof timer.unref === 'function') {
     timer.unref();
   }
   controller.signal.onabort = (): void => { timer && stop(timer); };
@@ -85,14 +101,14 @@ export function getBody(inputs: unknown[], isBodyRequest: boolean): { body: Form
     return {
       body: undefined,
       headers: {
-        'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(JSON.stringify(inputs)))
+        'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(jsonToString(inputs)))
       }
     };
   }
   // If we do not have a blob, simple output
   if (!inputs.some(isBlobLike)) {
     return {
-      body: JSON.stringify(inputs),
+      body: jsonToString(inputs),
       headers: {
         'Content-Type': 'application/json'
       }
@@ -115,27 +131,24 @@ export function getBody(inputs: unknown[], isBodyRequest: boolean): { body: Form
   return {
     body: form,
     headers: {
-      'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(JSON.stringify(plainInputs)))
+      'X-TRV-RPC-INPUTS': btoa(encodeURIComponent(jsonToString(plainInputs)))
     }
   };
 }
 
-export function consumeJSON<T>(text: string | unknown): T {
-  if (typeof text !== 'string') {
-    return consumeJSON(JSON.stringify(text));
-  } else if (text === null || text === undefined || text === '') {
+export function consumeJSON<T>(input: string | unknown): T {
+  let text: string;
+  if (input === null || input === undefined || input === '') {
     return undefined!;
+  } else if (typeof input !== 'string') {
+    text = jsonToString(input);
+  } else {
+    text = input;
   }
   try {
-    return JSON.parse(text, (key, value): unknown => {
-      if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[.]\d{3}Z/.test(value)) {
-        return new Date(value);
-      } else {
-        return value;
-      }
-    });
+    return stringToJson<T>(text);
   } catch (error) {
-    throw new Error(`Unable to parse response: ${text}, Unknown error: ${error}`);
+    throw new Error(`Unable to parse response: ${text}`, { cause: error });
   }
 }