@travetto/web-rpc 7.0.0-rc.2 → 7.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/web-rpc",
-  "version": "7.0.0-rc.2",
+  "version": "7.0.0-rc.3",
   "description": "RPC support for a Web Application",
   "keywords": [
     "web",
@@ -26,9 +26,9 @@
     "directory": "module/web-rpc"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.1",
-    "@travetto/schema": "^7.0.0-rc.1",
-    "@travetto/web": "^7.0.0-rc.2"
+    "@travetto/config": "^7.0.0-rc.2",
+    "@travetto/schema": "^7.0.0-rc.2",
+    "@travetto/web": "^7.0.0-rc.3"
   },
   "travetto": {
     "displayName": "Web RPC Support"

package/src/controller.ts

@@ -8,11 +8,11 @@ import {
 } from '@travetto/web';
 
 @Controller('/rpc')
-@ExcludeInterceptors(val => !(
-  val instanceof DecompressInterceptor ||
-  val instanceof BodyInterceptor ||
-  val instanceof RespondInterceptor ||
-  val.category === 'global'
+@ExcludeInterceptors(value => !(
+  value instanceof DecompressInterceptor ||
+  value instanceof BodyInterceptor ||
+  value instanceof RespondInterceptor ||
+  value.category === 'global'
 ))
 @IsPrivate()
 export class WebRpcController {
@@ -49,7 +49,7 @@ export class WebRpcController {
     } else if (Array.isArray(body)) { // Params passed via body
       params = body;
 
-      const bodyParamIdx = endpoint.parameters.findIndex((x) => x.location === 'body');
+      const bodyParamIdx = endpoint.parameters.findIndex((config) => config.location === 'body');
       if (bodyParamIdx >= 0) { // Re-assign body
         request.body = params[bodyParamIdx];
       }
@@ -59,7 +59,7 @@ export class WebRpcController {
       params = [];
     }
 
-    const final = endpoint.parameters.map((x, i) => (x.location === 'body' && paramInput) ? EndpointUtil.MissingParamSymbol : params[i]);
+    const final = endpoint.parameters.map((config, i) => (config.location === 'body' && paramInput) ? EndpointUtil.MissingParamSymbol : params[i]);
     WebCommonUtil.setRequestParams(request, final);
 
     // Dispatch

package/src/service.ts

@@ -28,16 +28,16 @@ export class WebRpcClientGeneratorService {
 
   async #getClasses(relativeTo: string): Promise<{ name: string, import: string }[]> {
     return ControllerRegistryIndex.getClasses()
-      .filter(x => {
-        const entry = RuntimeIndex.getEntry(Runtime.getSourceFile(x));
+      .filter(cls => {
+        const entry = RuntimeIndex.getEntry(Runtime.getSourceFile(cls));
         return entry && entry.role === 'std';
       })
-      .filter(x => SchemaRegistryIndex.getConfig(x).private !== true)
-      .map(x => {
-        const imp = ManifestModuleUtil.withOutputExtension(Runtime.getImport(x));
+      .filter(cls => SchemaRegistryIndex.getConfig(cls).private !== true)
+      .map(config => {
+        const imp = ManifestModuleUtil.withOutputExtension(Runtime.getImport(config));
         const base = Runtime.workspaceRelative(RuntimeIndex.manifest.build.typesFolder);
         return {
-          name: x.name,
+          name: config.name,
           import: path.relative(relativeTo, `${base}/node_modules/${imp}`)
         };
       });
@@ -56,15 +56,15 @@ export class WebRpcClientGeneratorService {
     const flavorOutputFile = path.resolve(config.output, path.basename(flavorSourceFile));
     const flavorSourceContents = (await fs.readFile(flavorSourceFile, 'utf8').catch(() => ''))
       .replaceAll(/^\s*\/\/\s*@ts-ignore[^\n]*\n/gsm, '')
-      .replaceAll(/^\/\/\s*#UNCOMMENT (.*)/gm, (_, v) => v);
+      .replaceAll(/^\/\/\s*#UNCOMMENT (.*)/gm, (_, line) => line);
 
     const factoryOutputFile = path.resolve(config.output, 'factory.ts');
     const factorySourceContents = [
       `import { ${clientFactory.name} } from './rpc';`,
-      ...classes.map((n) => `import type { ${n.name} } from '${n.import}';`),
+      ...classes.map((cls) => `import type { ${cls.name} } from '${cls.import}';`),
       '',
       `export const factory = ${clientFactory.name}<{`,
-      ...classes.map(x => `  ${x.name}: ${x.name};`),
+      ...classes.map(cls => `  ${cls.name}: ${cls.name};`),
       '}>();',
     ].join('\n');
 

package/support/cli.web_rpc-client.ts

@@ -28,18 +28,17 @@ export class CliWebRpcCommand implements CliCommandShape {
   }
 
   async main(type: WebRpcClient['type'] | 'config', output?: string): Promise<void> {
+    const service = await this.#service;
     if (type === 'config') {
-      const svc = await this.#service;
-      await svc.render();
+      await service.render();
     } else {
       if (!output) {
         throw new CliValidationResultError(this, [
           { message: 'output is required when type is not `config`', source: 'arg' }
         ]);
       }
-      const svc = await this.#service;
       output = path.resolve(output);
-      return svc.renderProvider({ type, output });
+      return service.renderProvider({ type, output });
     }
   }
 }

package/support/client/rpc-node.ts

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

package/support/client/rpc.ts

@@ -6,14 +6,14 @@ type PromiseFn = (...args: any) => Promise<unknown>;
 type PromiseRes<V extends PromiseFn> = Awaited<ReturnType<V>>;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isBlobMap = (x: any): x is Record<string, Blob> => x && typeof x === 'object' && x[Object.keys(x)[0]] instanceof Blob;
+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 = (x: any): x is Record<string, Blob> | Blob => x instanceof Blob || isBlobMap(x);
+const isBlobLike = (value: any): 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);
-  for (const [k, v] of Object.entries(toAdd)) { headers.set(k, v); }
+  for (const [key, value] of Object.entries(toAdd)) { headers.set(key, value); }
   return headers;
 };
 
@@ -42,26 +42,26 @@ 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,
-    decorate?: (opts: RpcRequest) => R
+    decorate?: (request: RpcRequest) => R
   ) => RpcClient<T, R>;
 
-function isResponse(v: unknown): v is Response {
-  return !!v && typeof v === 'object' && 'status' in v && !!v.status && 'headers' in v && !!v.headers;
+function isResponse(value: unknown): value is Response {
+  return !!value && typeof value === 'object' && 'status' in value && !!value.status && 'headers' in value && !!value.headers;
 }
 
-function isPlainObject(obj: unknown): obj is Record<string, unknown> {
-  return typeof obj === 'object' // separate from primitives
-    && obj !== undefined
-    && obj !== null         // is obvious
-    && obj.constructor === Object // separate instances (Array, DOM, ...)
-    && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' // separate from primitives
+    && value !== undefined
+    && value !== null         // is obvious
+    && value.constructor === Object // separate instances (Array, DOM, ...)
+    && Object.prototype.toString.call(value) === '[object Object]'; // separate build-in like Math
 }
 
 function registerTimeout<T extends (number | string | { unref(): unknown })>(
   controller: AbortController,
   timeout: number,
   start: (fn: (...args: unknown[]) => unknown, delay: number) => T,
-  stop: (val: T) => void
+  stop: (value: T) => void
 ): void {
   const timer = start(() => controller.abort(), timeout);
   if (!(typeof timer === 'number' || typeof timer === 'string')) {
@@ -99,14 +99,14 @@ export function getBody(inputs: unknown[], isBodyRequest: boolean): { body: Form
     };
   }
 
-  const plainInputs = inputs.map(x => isBlobLike(x) ? null : x);
+  const plainInputs = inputs.map(value => isBlobLike(value) ? null : value);
   const form = new FormData();
 
-  for (const inp of inputs.filter(isBlobLike)) {
-    if (inp instanceof Blob) {
-      form.append('file', inp, (inp instanceof File) ? inp.name : undefined);
+  for (const input of inputs.filter(isBlobLike)) {
+    if (input instanceof Blob) {
+      form.append('file', input, (input instanceof File) ? input.name : undefined);
     } else {
-      for (const [name, blob] of Object.entries(inp)) {
+      for (const [name, blob] of Object.entries(input)) {
         form.append(name, blob, (blob instanceof File) ? blob.name : undefined);
       }
     }
@@ -134,21 +134,21 @@ export function consumeJSON<T>(text: string | unknown): T {
         return value;
       }
     });
-  } catch (err) {
-    throw new Error(`Unable to parse response: ${text}, Unknown error: ${err}`);
+  } catch (error) {
+    throw new Error(`Unable to parse response: ${text}, Unknown error: ${error}`);
   }
 }
 
-export async function consumeError(err: unknown): Promise<Error> {
-  if (err instanceof Error) {
-    return err;
-  } else if (isResponse(err)) {
-    const out = new Error(err.statusText);
-    Object.assign(out, { status: err.status });
+export async function consumeError(error: unknown): Promise<Error> {
+  if (error instanceof Error) {
+    return error;
+  } else if (isResponse(error)) {
+    const out = new Error(error.statusText);
+    Object.assign(out, { status: error.status });
     return consumeError(out);
-  } else if (isPlainObject(err)) {
+  } else if (isPlainObject(error)) {
     const out = new Error();
-    Object.assign(out, err);
+    Object.assign(out, error);
     return consumeError(out);
   } else {
     return new Error('Unknown error');
@@ -198,12 +198,12 @@ export async function invokeFetch<T>(request: RpcRequest, ...params: unknown[]):
       try {
         resolved = await fetch(url, core);
         break;
-      } catch (err) {
+      } catch (error) {
         if (i < (core.retriesOnConnectFailure ?? 0)) {
-          await new Promise(r => setTimeout(r, 1000)); // Wait 1s
+          await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1s
           continue;
         } else {
-          throw err;
+          throw error;
         }
       }
     }
@@ -240,19 +240,19 @@ export async function invokeFetch<T>(request: RpcRequest, ...params: unknown[]):
       }
       throw responseObject;
     }
-  } catch (err) {
-    throw await request.consumeError!(err);
+  } catch (error) {
+    throw await request.consumeError!(error);
   }
 }
 
 export function clientFactory<T extends Record<string, {}>>(): RpcClientFactory<T> {
   // @ts-ignore
-  return function (opts, decorate) {
+  return function (request, decorate) {
     const client: RpcRequest = {
       consumeJSON,
       consumeError,
-      ...opts,
-      core: { timeout: 0, credentials: 'include', mode: 'cors', ...opts.core },
+      ...request,
+      core: { timeout: 0, credentials: 'include', mode: 'cors', ...request.core },
     };
     const cache: Record<string, unknown> = {};
     // @ts-ignore
@@ -267,7 +267,7 @@ export function clientFactory<T extends Record<string, {}>>(): RpcClientFactory<
             return cache[`${controller}/${endpoint}`] ??= Object.defineProperties(
               invokeFetch.bind(null, final),
               Object.fromEntries(
-                Object.entries(decorate?.(final) ?? {}).map(([k, v]) => [k, { value: v }])
+                Object.entries(decorate?.(final) ?? {}).map(([key, value]) => [key, { value }])
               )
             );
           }
@@ -277,10 +277,10 @@ export function clientFactory<T extends Record<string, {}>>(): RpcClientFactory<
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function withConfigFactoryDecorator(opts: RpcRequest) {
+export function withConfigFactoryDecorator(request: RpcRequest) {
   return {
     withConfig<V extends PromiseFn>(this: V, extra: Partial<RpcRequest['core']>, ...params: Parameters<V>): Promise<PromiseRes<V>> {
-      return invokeFetch({ ...opts, core: { ...opts.core, ...extra } }, ...params);
+      return invokeFetch({ ...request, core: { ...request.core, ...extra } }, ...params);
     }
   };
 }