Implement async server-side search (#1045)

Author: isc-bsaviano

src/api/atelier.d.ts

@@ -15,6 +15,8 @@ export interface Response<T = any> {
   status: ResponseStatus;
   console: string[];
   result: T;
+  /** Value of the `Retry-After` response header, if present */
+  retryafter?: string;
 }
 
 interface ServerInfoFeature {
@@ -77,3 +79,30 @@ export interface DeleteStatus {
   db: string;
   status: string;
 }
+
+interface AsyncCompileRequest {
+  request: "compile";
+  documents: string[];
+  source?: boolean;
+  flags?: string;
+}
+
+interface AsyncSearchRequest {
+  request: "search";
+  query: string;
+  regex?: boolean;
+  project?: string;
+  word?: boolean;
+  case?: boolean;
+  wild?: boolean;
+  documents?: string;
+  system?: boolean;
+  generated?: boolean;
+  mapped?: boolean;
+  max?: number;
+  include?: string;
+  exclude?: string;
+  console: false;
+}
+
+export type AsyncRequest = AsyncCompileRequest | AsyncSearchRequest;

src/api/index.ts

@@ -416,7 +416,7 @@ export class AtelierAPI {
       } else if (originalPath && /^[^/]+\/work\/[^/]+$/.test(originalPath)) {
         // This is a GET or DELETE /work request, so we need to check the Retry-After header
         if (response.headers.has("Retry-After")) {
-          data.result.retryafter = response.headers.get("Retry-After");
+          data.retryafter = response.headers.get("Retry-After");
         }
       }
 
@@ -617,30 +617,32 @@ export class AtelierAPI {
   }
 
   // v1+
-  private queueAsync(request: any): Promise<Atelier.Response> {
+  public queueAsync(request: Atelier.AsyncRequest): Promise<Atelier.Response> {
     return this.request(1, "POST", `${this.ns}/work`, request);
   }
 
   // v1+
-  private pollAsync(id: string): Promise<Atelier.Response> {
+  public pollAsync(id: string): Promise<Atelier.Response> {
     return this.request(1, "GET", `${this.ns}/work/${id}`);
   }
 
   // v1+
-  private cancelAsync(id: string): Promise<Atelier.Response> {
+  public cancelAsync(id: string): Promise<Atelier.Response> {
     return this.request(1, "DELETE", `${this.ns}/work/${id}`);
   }
 
   /**
    * Calls `cancelAsync()` repeatedly until the cancellation is confirmed.
    * The wait time between requests is 1 second.
    */
-  private async verifiedCancel(id: string): Promise<Atelier.Response> {
-    outputChannel.appendLine(
-      "\nWARNING: Compilation was cancelled. Partially-compiled documents may result in unexpected behavior."
-    );
+  public async verifiedCancel(id: string, compile = true): Promise<Atelier.Response> {
+    if (compile) {
+      outputChannel.appendLine(
+        "\nWARNING: Compilation was cancelled. Partially-compiled documents may result in unexpected behavior."
+      );
+    }
     let cancelResp = await this.cancelAsync(id);
-    while (cancelResp.result.retryafter) {
+    while (cancelResp.retryafter) {
       await new Promise((resolve) => {
         setTimeout(resolve, 1000);
       });
@@ -659,7 +661,7 @@ export class AtelierAPI {
       // The user cancelled the request, so cancel it on the server
       return this.verifiedCancel(id);
     }
-    if (pollResp.result.retryafter) {
+    if (pollResp.retryafter) {
       await new Promise((resolve) => {
         setTimeout(resolve, wait);
       });