Merge pull request #2009 from aeternity/middleware-next-prev

feat(middleware): allow navigate to next/prev pages

Author: davidyuk

src/Middleware.ts

@@ -1,10 +1,13 @@
-import { OperationOptions } from '@azure/core-client';
+import { OperationArguments, OperationOptions, OperationSpec } from '@azure/core-client';
 import { userAgentPolicyName, setClientRequestIdPolicyName } from '@azure/core-rest-pipeline';
 import {
   genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
   parseBigIntPolicy, genVersionCheckPolicy, genRetryOnFailurePolicy,
 } from './utils/autorest';
 import { Middleware as MiddlewareApi, MiddlewareOptionalParams, ErrorResponse } from './apis/middleware';
+import { operationSpecs } from './apis/middleware/middleware';
+import { IllegalArgumentError, InternalError } from './utils/errors';
+import { MiddlewarePage, isMiddlewareRawPage } from './utils/MiddlewarePage';
 
 export default class Middleware extends MiddlewareApi {
   /**
@@ -51,4 +54,57 @@ export default class Middleware extends MiddlewareApi {
     // TODO: use instead our retry policy
     this.pipeline.removePolicy({ name: 'defaultRetryPolicy' });
   }
+
+  /**
+   * Get a middleware response by path instead of a method name and arguments.
+   * @param pathWithQuery - a path to request starting with `/v3/`
+   */
+  async requestByPath<Response = unknown>(pathWithQuery: string): Promise<Response> {
+    const queryPos = pathWithQuery.indexOf('?');
+    const path = pathWithQuery.slice(0, queryPos === -1 ? pathWithQuery.length : queryPos);
+    const query = pathWithQuery.slice(queryPos === -1 ? pathWithQuery.length : queryPos + 1);
+
+    const operationSpec = operationSpecs.find((os) => {
+      let p = path;
+      if (os.path == null) return false;
+      const groups = os.path.replace(/{\w+}/g, '{param}').split('{param}');
+      while (groups.length > 0) {
+        const part = groups.shift();
+        if (part == null) throw new InternalError(`Unexpected operation spec path: ${os.path}`);
+        if (!p.startsWith(part)) return false;
+        p = p.replace(part, '');
+        if (groups.length > 0) p = p.replace(/^[\w.]+/, '');
+      }
+      return p === '';
+    });
+    if (operationSpec == null) {
+      throw new IllegalArgumentError(`Can't find operation spec corresponding to ${path}`);
+    }
+
+    return this.sendOperationRequest({}, {
+      ...operationSpec,
+      path,
+      urlParameters: operationSpec.urlParameters
+        ?.filter(({ parameterPath }) => parameterPath === '$host'),
+      queryParameters: Array.from(new URLSearchParams(query)).map(([key, value]) => ({
+        parameterPath: ['options', key],
+        mapper: {
+          defaultValue: value.toString(),
+          serializedName: key,
+          type: {
+            name: 'String',
+          },
+        },
+      })),
+    });
+  }
+
+  override async sendOperationRequest<T>(
+    operationArguments: OperationArguments,
+    operationSpec: OperationSpec,
+  ): Promise<T> {
+    const response = await super.sendOperationRequest(operationArguments, operationSpec);
+    if (!isMiddlewareRawPage(response)) return response as T;
+    return new MiddlewarePage(response, this) as T;
+  }
 }

src/index-browser.ts

@@ -72,6 +72,7 @@ export {
   default as MiddlewareSubscriber, MiddlewareSubscriberError, MiddlewareSubscriberDisconnected,
 } from './MiddlewareSubscriber';
 export { default as Middleware } from './Middleware';
+export { MiddlewarePageMissed } from './utils/MiddlewarePage';
 
 export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
 export {

src/utils/MiddlewarePage.ts

@@ -0,0 +1,66 @@
+/* eslint-disable max-classes-per-file */
+import type Middleware from '../Middleware';
+import { BaseError } from './errors';
+
+export interface MiddlewareRawPage {
+  data: unknown[];
+  next: string | null;
+  prev: string | null;
+}
+
+export function isMiddlewareRawPage(maybePage: unknown): maybePage is MiddlewareRawPage {
+  const testPage = maybePage as MiddlewareRawPage;
+  return testPage?.data != null && Array.isArray(testPage.data)
+    && 'next' in testPage
+    && 'prev' in testPage;
+}
+
+/**
+ * @category exception
+ */
+export class MiddlewarePageMissed extends BaseError {
+  constructor(isNext: boolean) {
+    super(`There is no ${isNext ? 'next' : 'previous'} page`);
+    this.name = 'MiddlewarePageMissed';
+  }
+}
+
+/**
+ * A wrapper around the middleware's page allowing to get the next/previous pages.
+ */
+export class MiddlewarePage<Item> {
+  readonly data: Item[];
+
+  readonly nextPath: null | string;
+
+  readonly prevPath: null | string;
+
+  readonly #middleware: Middleware;
+
+  constructor(rawPage: MiddlewareRawPage, middleware: Middleware) {
+    this.data = rawPage.data as Item[];
+    this.nextPath = rawPage.next;
+    this.prevPath = rawPage.prev;
+    this.#middleware = middleware;
+  }
+
+  /**
+   * Get the next page.
+   * Check the presence of `nextPath` to not fall outside existing pages.
+   * @throws MiddlewarePageMissed
+   */
+  async next(): Promise<MiddlewarePage<Item>> {
+    if (this.nextPath == null) throw new MiddlewarePageMissed(true);
+    return this.#middleware.requestByPath(this.nextPath);
+  }
+
+  /**
+   * Get the previous page.
+   * Check the presence of `prevPath` to not fall outside existing pages.
+   * @throws MiddlewarePageMissed
+   */
+  async prev(): Promise<MiddlewarePage<Item>> {
+    if (this.prevPath == null) throw new MiddlewarePageMissed(false);
+    return this.#middleware.requestByPath(this.prevPath);
+  }
+}

src/utils/autorest.ts

@@ -48,9 +48,9 @@ export const createSerializer = (
   });
 };
 
-// 16 === Number.MAX_SAFE_INTEGER.toString().length
-const bigIntPropertyRe = /("\w+":\s*)(\d{16,})(\s*[,}])/m;
-const bigIntArrayItemRe = /([[,]\s*)(\d{16,})\b/m;
+const safeLength = Number.MAX_SAFE_INTEGER.toString().length;
+const bigIntPropertyRe = new RegExp(String.raw`("\w+":\s*)(\d{${safeLength},})(\s*[,}])`, 'm');
+const bigIntArrayItemRe = new RegExp(String.raw`([[,]\s*)(\d{${safeLength},})\b`, 'm');
 export const parseBigIntPolicy: PipelinePolicy = {
   name: 'parse-big-int',
   async sendRequest(request, next) {