feat: adds new decorators following the typescript v5 standard + updates to TypeScript v5 (#3951)

Signed-off-by: Simeon Nakov <simeon.nakov@limechain.tech>

Author: simzzz

package-lock.json

@@ -35,7 +35,7 @@
     "prettier": "^3.0.3",
     "replace": "^1.2.2",
     "ts-node": "^10.9.2",
-    "typescript": "^4.6.3"
+    "typescript": "^5.8.3"
   },
   "workspaces": {
     "packages": [

package.json

@@ -22,6 +22,6 @@
   "devDependencies": {
     "chai": "^4.3.6",
     "ts-mocha": "^9.0.2",
-    "typescript": "^4.6.4"
+    "typescript": "^5.8.3"
   }
 }

packages/config-service/package.json

@@ -18,7 +18,7 @@
     "redis-memory-server": "^0.12.1",
     "sinon": "^14.0.0",
     "ts-mocha": "^9.0.2",
-    "typescript": "^4.6.4"
+    "typescript": "^5.8.3"
   },
   "scripts": {
     "build": "pnpm run clean && pnpm run compile",

packages/relay/package.json

@@ -27,8 +27,55 @@ interface CacheOptions {
 }
 
 /**
- * Iterates through the provided 'params' array and checks if any argument in 'args' at the specified 'index'
- * matches one of the pipe-separated values in 'value'. If a match is found, caching should be skipped.
+ * Uses a `CacheService` to attempt to retrieve a cached result before executing the original method. If
+ * no cached response exists, the method is executed and its result may be stored in the cache depending on configurable
+ * options. Caching can be conditionally skipped based on runtime arguments via `skipParams` (for positional args)
+ * and `skipNamedParams` (for object args).
+ *
+ * @param cacheService - The caching service used to store and retrieve cache entries.
+ * @param options - Optional configuration for caching behavior.
+ *   @property skipParams - An array of rules for skipping caching based on specific argument values.
+ *   @property skipNamedParams - An array of rules for skipping caching based on fields within argument objects.
+ *   @property ttl - Optional time-to-live for the cache entry; falls back to global config if not provided.
+ *
+ * @returns A method decorator function that wraps the original method with caching logic.
+ *
+ * @example
+ *   @cache(CacheService, { skipParams: [...], skipNamesParams: [...], ttl: 300 })
+ */
+export function cache(cacheService: CacheService, options: CacheOptions = {}) {
+  return function (target: any, context: ClassMethodDecoratorContext) {
+    const methodName = String(context.name);
+
+    return async function (this: any, ...args: unknown[]) {
+      const requestDetails = extractRequestDetails(args);
+      const cacheKey = generateCacheKey(methodName, args);
+
+      const cachedResponse = await cacheService.getAsync(cacheKey, methodName, requestDetails);
+      if (cachedResponse) return cachedResponse;
+
+      const result = await target.apply(this, args);
+      if (
+        result &&
+        !shouldSkipCachingForSingleParams(args, options.skipParams) &&
+        !shouldSkipCachingForNamedParams(args, options.skipNamedParams)
+      ) {
+        await cacheService.set(
+          cacheKey,
+          result,
+          methodName,
+          requestDetails,
+          options.ttl ?? ConfigService.get('CACHE_TTL'),
+        );
+      }
+      return result;
+    };
+  };
+}
+
+/**
+ * This is a predicate function that takes a list of arguments and parameters,
+ * and it checks whether the given function should skip caching based on specific positional argument values.
  *
  * @param args - The arguments passed to the method in an array
  * @param params - An array of CacheSingleParam caching rules
@@ -151,56 +198,6 @@ const extractRequestDetails = (args: unknown[]): RequestDetails => {
   return new RequestDetails({ requestId: '', ipAddress: '' });
 };
 
-/**
- * This decorator uses a `CacheService` to attempt to retrieve a cached result before executing the original method. If
- * no cached response exists, the method is executed and its result may be stored in the cache depending on configurable
- * options. Caching can be conditionally skipped based on runtime arguments via `skipParams` (for positional args)
- * and `skipNamedParams` (for object args).
- *
- * @param cacheService - The caching service used to store and retrieve cache entries.
- * @param options - Optional configuration for caching behavior.
- *   @property skipParams - An array of rules for skipping caching based on specific argument values.
- *   @property skipNamedParams - An array of rules for skipping caching based on fields within argument objects.
- *   @property ttl - Optional time-to-live for the cache entry; falls back to global config if not provided.
- *
- * @returns A method decorator function that wraps the original method with caching logic.
- *
- * @example
- *   @cache(CacheService, { skipParams: [...], skipNamesParams: [...], ttl: 300 })
- */
-export function cache(cacheService: CacheService, options: CacheOptions = {}) {
-  return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
-    const method = descriptor.value;
-
-    descriptor.value = async function (...args: unknown[]) {
-      const requestDetails = extractRequestDetails(args);
-      const cacheKey = generateCacheKey(method.name, args);
-
-      const cachedResponse = await cacheService.getAsync(cacheKey, method, requestDetails);
-      if (cachedResponse) {
-        return cachedResponse;
-      }
-
-      const result = await method.apply(this, args);
-      if (
-        result &&
-        !shouldSkipCachingForSingleParams(args, options?.skipParams) &&
-        !shouldSkipCachingForNamedParams(args, options?.skipNamedParams)
-      ) {
-        await cacheService.set(
-          cacheKey,
-          result,
-          method,
-          requestDetails,
-          options?.ttl ?? ConfigService.get('CACHE_TTL'),
-        );
-      }
-
-      return result;
-    };
-  };
-}
-
 // export private methods under __test__ "namespace" but using const
 // due to `ES2015 module syntax is preferred over namespaces` eslint warning
 export const __test__ = {

packages/relay/src/lib/decorators/cache.decorator.ts

@@ -20,12 +20,12 @@ export const RPC_METHOD_KEY = 'hedera-rpc-method';
  * }
  * ```
  *
- * @param _target - The prototype of the class (ignored in this implementation)
- * @param _propertyKey - The name of the method being decorated (ignored in this implementation)
- * @param descriptor - The property descriptor for the method
- * @returns The same property descriptor, allowing for decorator composition
+ * @param target - The method function
+ * @param context - The decorator context
+ * @returns The method function with RPC metadata attached
  */
-export function rpcMethod(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
-  descriptor.value[RPC_METHOD_KEY] = true;
-  return descriptor;
+export function rpcMethod(target: any, _context: ClassMethodDecoratorContext): any {
+  target[RPC_METHOD_KEY] = true;
+
+  return target;
 }

packages/relay/src/lib/decorators/rpcMethod.decorator.ts

@@ -36,14 +36,14 @@ export const RPC_LAYOUT = {
  * ```typescript
  * // Method that only needs requestDetails
  * @rpcMethod
- * @rpcParamSpecialLayout(RPC_LAYOUT.REQUEST_DETAILS_ONLY)
+ * @rpcParamLayoutConfig(RPC_LAYOUT.REQUEST_DETAILS_ONLY)
  * blockNumber(requestDetails: RequestDetails): Promise<string> {
  *   // Implementation
  * }
  *
  * // Method with specific parameter transformations
  * @rpcMethod
- * @rpcParamSpecialLayout(RPC_LAYOUT.custom(params => [params[0], params[1]]))
+ * @rpcParamLayoutConfig(RPC_LAYOUT.custom(params => [params[0], params[1]]))
  * estimateGas(transaction: IContractCallRequest, _blockParam: string | null, requestDetails: RequestDetails,): Promise<string | JsonRpcError> {
  *   // Implementation
  * }
@@ -52,8 +52,8 @@ export const RPC_LAYOUT = {
  * @param layout - Parameter layout specification
  */
 export function rpcParamLayoutConfig(layout: string | ParamTransformFn) {
-  return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
-    descriptor.value[RPC_PARAM_LAYOUT_KEY] = layout;
-    return descriptor;
+  return function (target: any, _context: ClassMethodDecoratorContext): any {
+    target[RPC_PARAM_LAYOUT_KEY] = layout;
+    return target;
   };
 }

packages/relay/src/lib/decorators/rpcParamLayoutConfig.decorator.ts

@@ -49,10 +49,11 @@ export const RPC_PARAM_VALIDATION_RULES_KEY = 'hedera-rpc-param-validation-rules
  * @returns Method decorator function
  */
 export function rpcParamValidationRules(validationRules: Record<number, IParamValidation>) {
-  return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+  return function (target: any, _context: ClassMethodDecoratorContext): any {
     // Store validation rules directly on the function as a property
-    descriptor.value[RPC_PARAM_VALIDATION_RULES_KEY] = validationRules;
-    return descriptor;
+    target[RPC_PARAM_VALIDATION_RULES_KEY] = validationRules;
+
+    return target;
   };
 }
 

packages/relay/src/lib/validators/index.ts

@@ -153,9 +153,8 @@ describe('rpcParamValidationRules decorator', () => {
 
   describe('Multiple decorators interaction', () => {
     it('should work alongside other decorators', () => {
-      const mockDecorator = (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => {
-        descriptor.value.MOCK_KEY = 'mock-value';
-        return descriptor;
+      const mockDecorator = (target: any, _context: ClassMethodDecoratorContext): void => {
+        target.MOCK_KEY = 'mock-value';
       };
 
       class TestMultiDecoratorClass {

packages/relay/tests/lib/decorators/rpcParamSchema.spec.ts

@@ -14,7 +14,6 @@
     "declaration": true,
     "strict": true,
     "sourceMap": true,
-    "experimentalDecorators": true,
     "skipLibCheck": true
   },
   "include": ["src"]