feat: 🎸 reduce size of client-side bundle

streamich · streamich · commit 344a302ada4b · 2024-10-04T10:50:57.000+02:00
diff --git a/src/__demos__/json-crdt-server/routes/index.ts b/src/__demos__/json-crdt-server/routes/index.ts
@@ -10,6 +10,7 @@ import {LevelStore} from '../services/blocks/store/level/LevelStore';
 import {ClassicLevel} from 'classic-level';
 import {Store} from '../services/blocks/store/types';
 import type {RouteDeps} from './types';
+import {TypedRpcError} from '../../../common/rpc/caller/error/typed';
 
 export const createRouter = (services: Services) => {
   const router = ObjectValue.create(system);
@@ -28,10 +29,10 @@ export const createCaller = (services: Services = new Services()) => {
     router,
     wrapInternalError: (error: unknown) => {
       if (error instanceof RpcValue) return error;
-      if (error instanceof RpcError) return RpcError.value(error);
+      if (error instanceof RpcError) return TypedRpcError.value(error);
       // tslint:disable-next-line:no-console
       console.error(error);
-      return RpcError.valueFrom(error);
+      return TypedRpcError.valueFrom(error);
     },
   });
   return {router, caller, services};
diff --git a/src/common/codec/binary/BinaryRpcMessageCodec.ts b/src/common/codec/binary/BinaryRpcMessageCodec.ts
@@ -1,6 +1,6 @@
 import {RpcMessageFormat} from '../constants';
 import {decode} from './decode';
-import * as msg from '../../messages';
+import type * as msg from '../../messages';
 import type {Uint8ArrayCut} from '@jsonjoy.com/util/lib/buffers/Uint8ArrayCut';
 import type {JsonValueCodec} from '@jsonjoy.com/json-pack/lib/codecs/types';
 import type {RpcMessageCodec} from '../types';
diff --git a/src/common/codec/compact/CompactRpcMessageCodec.ts b/src/common/codec/compact/CompactRpcMessageCodec.ts
@@ -1,8 +1,9 @@
 import {RpcMessageFormat} from '../constants';
-import {RpcError, RpcErrorCodes} from '../../rpc/caller/error';
+import {RpcError, RpcErrorCodes} from '../../rpc/caller/error/RpcError';
 import * as msg from '../../messages';
 import {CompactMessageType} from './constants';
 import {RpcValue} from '../../messages/Value';
+import {TypedRpcError} from '../../rpc/caller/error/typed';
 import type {JsonEncoder} from '@jsonjoy.com/json-pack/lib/json/JsonEncoder';
 import type {RpcMessageCodec} from '../types';
 import type {JsonValueCodec} from '@jsonjoy.com/json-pack/lib/codecs/types';
@@ -47,7 +48,7 @@ const fromJson = (arr: unknown | unknown[] | types.CompactMessage): msg.Reactive
       return new msg.NotificationMessage(arr[1], new RpcValue(arr[2], undefined));
     }
   }
-  throw RpcError.value(RpcError.validation('Unknown message type'));
+  throw TypedRpcError.value(RpcError.validation('Unknown message type'));
 };
 
 const encodeCompactWithNameAndPayload = (
@@ -68,7 +69,10 @@ const encodeCompactWithNameAndPayload = (
       if (value.type) value.type.encoder(codec.format)(value.data, encoder);
       else encoder.writeAny(value.data);
     }
-  } else if (typeof (encoder as any as JsonEncoder).writeStartArr === 'function' && typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function') {
+  } else if (
+    typeof (encoder as any as JsonEncoder).writeStartArr === 'function' &&
+    typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function'
+  ) {
     const jsonEncoder = encoder as any as JsonEncoder;
     const value = msg.value;
     jsonEncoder.writeStartArr();
@@ -105,7 +109,10 @@ const encodeCompactWithPayload = (
         value.type.encoder(codec.format)(value.data, encoder);
       } else encoder.writeAny(value.data);
     }
-  } else if (typeof (encoder as any as JsonEncoder).writeStartArr === 'function' && typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function') {
+  } else if (
+    typeof (encoder as any as JsonEncoder).writeStartArr === 'function' &&
+    typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function'
+  ) {
     const jsonEncoder = encoder as any as JsonEncoder;
     const value = msg.value;
     jsonEncoder.writeStartArr();
@@ -140,7 +147,10 @@ export class CompactRpcMessageCodec implements RpcMessageCodec {
           if (value.type) value.type.encoder(codec.format)(value.data, encoder);
           else encoder.writeAny(value.data);
         }
-      } else if (typeof (encoder as any as JsonEncoder).writeStartArr === 'function' && typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function') {
+      } else if (
+        typeof (encoder as any as JsonEncoder).writeStartArr === 'function' &&
+        typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function'
+      ) {
         const jsonEncoder = encoder as any as JsonEncoder;
         const value = message.value;
         jsonEncoder.writeStartArr();
@@ -183,7 +193,10 @@ export class CompactRpcMessageCodec implements RpcMessageCodec {
       const length = batch.length;
       binaryEncoder.writeArrHdr(length);
       for (let i = 0; i < length; i++) this.encodeMessage(jsonCodec, batch[i]);
-    } else if (typeof (encoder as any as JsonEncoder).writeStartArr === 'function' && typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function') {
+    } else if (
+      typeof (encoder as any as JsonEncoder).writeStartArr === 'function' &&
+      typeof (encoder as any as JsonEncoder).writeArrSeparator === 'function'
+    ) {
       const jsonEncoder = encoder as any as JsonEncoder;
       const length = batch.length;
       const last = length - 1;
diff --git a/src/common/codec/compact/__tests__/smoke-tests.spec.ts b/src/common/codec/compact/__tests__/smoke-tests.spec.ts
@@ -14,7 +14,7 @@ import {
   ResponseUnsubscribeMessage,
 } from '../../../messages';
 import {RpcValue} from '../../../messages/Value';
-import {RpcError} from '../../../rpc/caller/error';
+import {TypedRpcError} from '../../../rpc/caller/error/typed';
 
 const writer = new Writer(8 * Math.round(Math.random() * 100));
 const codecs = new Codecs(writer);
@@ -84,7 +84,7 @@ for (const jsonCodec of codecList) {
     });
 
     test('Response Error typed', () => {
-      const value = RpcError.internalErrorValue(null);
+      const value = TypedRpcError.internalErrorValue(null);
       const message = new ResponseErrorMessage(123, value);
       const encoded = codec.encode(jsonCodec, [message]);
       const decoded1 = jsonCodec.decoder.read(encoded);
diff --git a/src/common/codec/json-rpc-2/JsonRpc2RpcMessageCodec.ts b/src/common/codec/json-rpc-2/JsonRpc2RpcMessageCodec.ts
@@ -2,7 +2,7 @@ import {EncodingFormat} from '@jsonjoy.com/json-pack/lib/constants';
 import {TlvBinaryJsonEncoder} from '@jsonjoy.com/json-pack/lib/types';
 import {JsonJsonValueCodec} from '@jsonjoy.com/json-pack/lib/codecs/json';
 import {RpcMessageFormat} from '../constants';
-import {RpcError} from '../../rpc/caller/error';
+import {RpcError} from '../../rpc/caller/error/RpcError';
 import {RpcValue} from '../../messages/Value';
 import * as msg from '../../messages';
 import * as schema from './schema';
diff --git a/src/common/rpc/RpcMessageBatchProcessor.ts b/src/common/rpc/RpcMessageBatchProcessor.ts
@@ -1,6 +1,7 @@
 import * as msg from '../messages';
-import {RpcError, RpcErrorValue} from './caller';
+import {RpcErrorValue} from './caller';
 import {validateId, validateMethod} from './validation';
+import {TypedRpcError} from './caller/error/typed';
 import type {RpcCaller} from './caller/RpcCaller';
 
 export type IncomingBatchMessage =
@@ -59,7 +60,7 @@ export class RpcMessageBatchProcessor<Ctx = unknown> {
       }
       return result;
     } catch (error) {
-      const value = RpcError.internalErrorValue(error);
+      const value = TypedRpcError.internalErrorValue(error);
       return [new msg.ResponseErrorMessage(-1, value)];
     }
   }
diff --git a/src/common/rpc/RpcMessageStreamProcessor.ts b/src/common/rpc/RpcMessageStreamProcessor.ts
@@ -1,10 +1,11 @@
 import * as msg from '../messages';
 import {TimedQueue} from '../util/TimedQueue';
-import {RpcErrorCodes, RpcError} from './caller/error';
+import {RpcErrorCodes, RpcError} from './caller/error/RpcError';
 import {RpcValue} from '../messages/Value';
 import {subscribeCompleteObserver} from '../util/subscribeCompleteObserver';
 import type {RpcCaller} from './caller/RpcCaller';
 import type {Call, RpcApiMap} from './caller/types';
+import {TypedRpcError} from './caller/error/typed';
 
 type Send = (messages: (msg.ReactiveRpcServerMessage | msg.NotificationMessage)[]) => void;
 
@@ -130,7 +131,7 @@ export class RpcMessageStreamProcessor<Ctx = unknown> {
     this.send = <any>(() => {});
     for (const call of this.activeStreamCalls.values()) {
       try {
-        call.req$.error(RpcError.valueFromCode(reason));
+        call.req$.error(TypedRpcError.valueFromCode(reason));
         call.stop$.next(null);
       } catch (error) {
         // tslint:disable-next-line no-console
@@ -145,7 +146,7 @@ export class RpcMessageStreamProcessor<Ctx = unknown> {
   }
 
   private sendError(id: number, code: RpcErrorCodes): void {
-    const data = RpcError.valueFromCode(code);
+    const data = TypedRpcError.valueFromCode(code);
     this.sendErrorMessage(id, data);
   }
 
diff --git a/src/common/rpc/caller/ObjectValueCaller.ts b/src/common/rpc/caller/ObjectValueCaller.ts
@@ -1,4 +1,4 @@
-import {RpcError} from './error';
+import {RpcError} from './error/RpcError';
 import {RpcCaller, type RpcApiCallerOptions} from './RpcCaller';
 import {type AbstractType, FunctionStreamingType, FunctionType} from 'json-joy/lib/json-type/type/classes';
 import {printTree} from 'sonic-forest/lib/print/printTree';
@@ -90,7 +90,7 @@ export class ObjectValueCaller<V extends ObjectValue<ObjectType<any>>, Ctx = unk
           const error: any = validator(req);
           if (error) {
             const message = error.message + (Array.isArray(error?.path) ? ' Path: /' + error.path.join('/') : '');
-            throw RpcError.value(RpcError.validation(message, error));
+            throw RpcError.validation(message, error);
           }
         };
     method =
diff --git a/src/common/rpc/caller/RpcCaller.ts b/src/common/rpc/caller/RpcCaller.ts
@@ -1,6 +1,7 @@
 import {firstValueFrom, from, Observable, Subject} from 'rxjs';
 import {catchError, finalize, first, map, mergeWith, share, switchMap, take, takeUntil, tap} from 'rxjs/operators';
-import {RpcError, RpcErrorCodes, RpcErrorValue} from './error';
+import {RpcError, RpcErrorCodes, RpcErrorValue} from './error/RpcError';
+import {TypedRpcError} from './error/typed';
 import {RpcValue} from '../../messages/Value';
 import {StaticRpcMethod} from '../methods/StaticRpcMethod';
 import {BufferSubject} from '../../../util/rx/BufferSubject';
@@ -22,9 +23,9 @@ export interface RpcApiCallerOptions<Ctx = unknown> {
   wrapInternalError?: (error: unknown) => unknown;
 }
 
-const INVALID_REQUEST_ERROR_VALUE = RpcError.value(RpcError.badRequest());
+const INVALID_REQUEST_ERROR_VALUE = TypedRpcError.value(RpcError.badRequest());
 
-const defaultWrapInternalError = (error: unknown) => RpcError.valueFrom(error);
+const defaultWrapInternalError = (error: unknown) => TypedRpcError.valueFrom(error);
 
 /**
  * Implements methods to call Reactive-RPC methods on the server.
@@ -50,7 +51,7 @@ export class RpcCaller<Ctx = unknown> {
 
   public getMethodStrict(name: string): StaticRpcMethod<Ctx> | StreamingRpcMethod<Ctx> {
     const method = this.getMethod(name);
-    if (!method) throw RpcError.valueFromCode(RpcErrorCodes.METHOD_NOT_FOUND);
+    if (!method) throw TypedRpcError.valueFromCode(RpcErrorCodes.METHOD_NOT_FOUND);
     return method;
   }
 
@@ -70,7 +71,7 @@ export class RpcCaller<Ctx = unknown> {
   }
 
   protected wrapValidationError(error: unknown): RpcErrorValue {
-    return RpcError.valueFrom(error, INVALID_REQUEST_ERROR_VALUE);
+    return TypedRpcError.valueFrom(error, INVALID_REQUEST_ERROR_VALUE);
   }
 
   /**
@@ -209,13 +210,13 @@ export class RpcCaller<Ctx = unknown> {
           error$.complete();
         }),
         catchError((error) => {
-          throw RpcError.valueFrom(error);
+          throw TypedRpcError.valueFrom(error);
         }),
       );
 
       return {req$, reqUnsubscribe$, stop$, res$: $resWithErrorsFormatted.pipe(takeUntil(stop$))};
     } catch (error) {
-      const errorFormatted = RpcError.valueFrom(error);
+      const errorFormatted = TypedRpcError.valueFrom(error);
       req$.error(errorFormatted);
       const res$ = new Subject<RpcValue>();
       res$.error(errorFormatted);
diff --git a/src/common/rpc/caller/TypeRouterCaller.ts b/src/common/rpc/caller/TypeRouterCaller.ts
@@ -1,8 +1,9 @@
-import {RpcError} from './error';
+import {RpcError} from './error/RpcError';
 import {RpcCaller, type RpcApiCallerOptions} from './RpcCaller';
 import {type AbstractType, FunctionStreamingType, FunctionType} from 'json-joy/lib/json-type/type/classes';
 import {StaticRpcMethod, type StaticRpcMethodOptions} from '../methods/StaticRpcMethod';
 import {StreamingRpcMethod, type StreamingRpcMethodOptions} from '../methods/StreamingRpcMethod';
+import {TypedRpcError} from './error/typed';
 import type {Schema, SchemaOf, TypeOf, TypeSystem} from 'json-joy/lib/json-type';
 import type {TypeRouter} from 'json-joy/lib/json-type/system/TypeRouter';
 import type {RpcValue} from '../../messages/Value';
@@ -44,7 +45,7 @@ export class TypeRouterCaller<Router extends TypeRouter<any>, Ctx = unknown> ext
           const error = validator(req);
           if (error) {
             const message = error.message + (Array.isArray(error?.path) ? ' Path: /' + error.path.join('/') : '');
-            throw RpcError.value(RpcError.validation(message, error));
+            throw TypedRpcError.value(RpcError.validation(message, error));
           }
         };
     method =
diff --git a/src/common/rpc/caller/TypedApiCaller.ts b/src/common/rpc/caller/TypedApiCaller.ts
@@ -1,4 +1,5 @@
-import {RpcError, RpcErrorCodes} from './error';
+import {RpcErrorCodes} from './error/RpcError';
+import {TypedRpcError} from './error/typed';
 import {RpcCaller, RpcApiCallerOptions} from './RpcCaller';
 import {FunctionStreamingType, FunctionType} from 'json-joy/lib/json-type/type/classes';
 import {StaticRpcMethod, type StaticRpcMethodOptions} from '../methods/StaticRpcMethod';
@@ -57,12 +58,12 @@ export class TypedApiCaller<Types extends TypeMap, Ctx = unknown> extends RpcCal
     const validate = customValidator
       ? (req: unknown) => {
           const error = validator(req);
-          if (error) throw RpcError.valueFromCode(RpcErrorCodes.BAD_REQUEST);
+          if (error) throw TypedRpcError.valueFromCode(RpcErrorCodes.BAD_REQUEST);
           customValidator(req);
         }
       : (req: unknown) => {
           const error = validator(req);
-          if (error) throw RpcError.valueFromCode(RpcErrorCodes.BAD_REQUEST);
+          if (error) throw TypedRpcError.valueFromCode(RpcErrorCodes.BAD_REQUEST);
         };
     const isStaticMethodAlias = alias.type instanceof FunctionType;
     const isStreamingMethodAlias = alias.type instanceof FunctionStreamingType;
@@ -87,7 +88,7 @@ export class TypedApiCaller<Types extends TypeMap, Ctx = unknown> extends RpcCal
 
   public get<K extends keyof Types>(id: K): MethodDefinition<Ctx, Types[K]> {
     const method = this.methods.get(id as string) as any;
-    if (!method) throw RpcError.valueFromCode(RpcErrorCodes.METHOD_NOT_FOUND);
+    if (!method) throw TypedRpcError.valueFromCode(RpcErrorCodes.METHOD_NOT_FOUND);
     return method;
   }
 }
diff --git a/src/common/rpc/caller/__tests__/RpcApiCaller.spec.ts b/src/common/rpc/caller/__tests__/RpcApiCaller.spec.ts
@@ -5,7 +5,7 @@ import {runApiTests} from '../../__tests__/runApiTests';
 import {sampleApi} from '../../__tests__/sample-api';
 import {of} from '../../../util/of';
 import {StreamingRpcMethod} from '../../methods/StreamingRpcMethod';
-import {RpcError} from '../error';
+import {TypedRpcError} from '../error/typed';
 
 const setup = () => {
   const caller = new ApiRpcCaller<any, object>({
@@ -46,7 +46,7 @@ describe('static calls', () => {
       },
     });
     const [, error] = await of(caller.call('test', {}, {}));
-    expect(error).toEqual(RpcError.internalErrorValue(null));
+    expect(error).toEqual(TypedRpcError.internalErrorValue(null));
   });
 });
 
@@ -95,10 +95,10 @@ describe('streaming calls', () => {
     });
 
     const [, error1] = await of(caller.call('test', {}, {}));
-    expect(error1).toEqual(RpcError.internalErrorValue(null));
+    expect(error1).toEqual(TypedRpcError.internalErrorValue(null));
 
     const [, error2] = await of(Rx.firstValueFrom(caller.call$('test', Rx.of(undefined), {})));
-    expect(error2).toEqual(RpcError.internalErrorValue(null));
+    expect(error2).toEqual(TypedRpcError.internalErrorValue(null));
   });
 });
 
diff --git a/src/common/rpc/caller/error/RpcError.ts b/src/common/rpc/caller/error/RpcError.ts
@@ -1,5 +1,5 @@
 import {RpcValue} from '../../../messages/Value';
-import {IRpcError, RpcErrorType} from './RpcErrorType';
+import type {IRpcError} from './RpcErrorType';
 
 export enum RpcErrorCodes {
   /** Any unknown sever error is wrapped into INTERNAL_ERROR, error 500. */
@@ -65,24 +65,6 @@ export class RpcError extends Error implements IRpcError {
     return RpcError.fromCode(RpcErrorCodes.BAD_REQUEST, message, meta);
   }
 
-  public static value(error: RpcError): RpcErrorValue {
-    return new RpcValue(error, RpcErrorType);
-  }
-
-  public static valueFrom(error: unknown, def = RpcError.internalErrorValue(error)): RpcErrorValue {
-    if (error instanceof RpcValue && error.data instanceof RpcError && error.type === RpcErrorType) return error;
-    if (error instanceof RpcError) return RpcError.value(error);
-    return def;
-  }
-
-  public static valueFromCode(errno: RpcErrorCodes, message?: string): RpcErrorValue {
-    return RpcError.value(RpcError.fromCode(errno, message));
-  }
-
-  public static internalErrorValue(originalError: unknown): RpcErrorValue {
-    return RpcError.value(RpcError.internal(originalError));
-  }
-
   public static isRpcError(error: unknown): error is RpcError {
     return error instanceof RpcError;
   }
diff --git a/src/common/rpc/caller/error/RpcErrorType.ts b/src/common/rpc/caller/error/RpcErrorType.ts
@@ -1,4 +1,11 @@
-import {ResolveType, t} from 'json-joy/lib/json-type';
+import {type ResolveType, t} from 'json-joy/lib/json-type';
+
+/**
+ * @protected
+ *
+ * Do not import from this module on the client side. It will import the whole
+ * `json-type` and `json-expression` libraries, due to `t` builder.
+ */
 
 export const RpcErrorType = t
   .Object(
diff --git a/src/common/rpc/caller/error/index.ts b/src/common/rpc/caller/error/index.ts
diff --git a/src/common/rpc/caller/error/typed.ts b/src/common/rpc/caller/error/typed.ts
diff --git a/src/common/rpc/caller/index.ts b/src/common/rpc/caller/index.ts
diff --git a/src/common/rpc/validation.ts b/src/common/rpc/validation.ts
diff --git a/src/server/uws/RpcApp.ts b/src/server/uws/RpcApp.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import * as msg from '../messages';`
`2`		`-import {RpcError, RpcErrorValue} from './caller';`
	`2`	`+import {RpcErrorValue} from './caller';`
`3`	`3`	`import {validateId, validateMethod} from './validation';`
	`4`	`+import {TypedRpcError} from './caller/error/typed';`
`4`	`5`	`import type {RpcCaller} from './caller/RpcCaller';`
`5`	`6`
`6`	`7`	`export type IncomingBatchMessage =`
`@@ -59,7 +60,7 @@ export class RpcMessageBatchProcessor<Ctx = unknown> {`
`59`	`60`	`}`
`60`	`61`	`return result;`
`61`	`62`	`} catch (error) {`
`62`		`- const value = RpcError.internalErrorValue(error);`
	`63`	`+ const value = TypedRpcError.internalErrorValue(error);`
`63`	`64`	`return [new msg.ResponseErrorMessage(-1, value)];`
`64`	`65`	`}`
`65`	`66`	`}`