fix(query): remove record api

src/api/dataops/queries/baseQuery.spec.ts

@@ -121,6 +121,6 @@ describe("execute method", () => {
   it("should call queryExecuter.executeRestRequest()", () => {
     let { subject, requestExecuterMock } = createSubject({action: QueryAction.select});
     subject.execute();
-    expect(requestExecuterMock.executeRestRequest).toHaveBeenCalled();
+    expect(requestExecuterMock.executeRequest).toHaveBeenCalled();
   });
 });

src/api/dataops/queries/baseQuery.ts

@@ -80,13 +80,6 @@ export abstract class BaseQuery<T> {
    * @returns Result of this operation with the affected data
    */
   public execute(): Promise<T[]> {
-    /* if it is a select request and it has no query conditions
-        call record (rest) API, otherwise use query API
-     */
-    if (this.compiledRequest.action === QueryAction.select && !this.compiledRequest.params) {
-      return this.queryExecuter.executeRestRequest();
-    } else {
-      return this.queryExecuter.executeQueryRequest(this.compiledRequest);
-    }
+    return this.queryExecuter.executeRequest(this.compiledRequest);
   }
 }

src/api/dataops/queries/deleteQuery.spec.ts

@@ -38,8 +38,8 @@ describe("QueryRequest class", () => {
   it("should correct execute the query", () => {
     let qe = createRequestExecuterMock(projectID, dataset);
     let subject: any = new DeleteQuery(qe, dataset);
-    spyOn(subject["queryExecuter"], "executeQueryRequest");
+    spyOn(subject["queryExecuter"], "executeRequest");
     subject.execute();
-    expect(subject["queryExecuter"].executeQueryRequest).toHaveBeenLastCalledWith({action: "delete"});
+    expect(subject["queryExecuter"].executeRequest).toHaveBeenLastCalledWith({action: "delete"});
   });
 });

src/api/dataops/queries/insertQuery.spec.ts

@@ -1,6 +1,5 @@
 // tslint:disable:no-string-literal
 import { createRequestExecuterMock } from "../../../../spec/testUtils";
-import { Methods } from "../../../internal/requestAdapter";
 import { InsertQuery } from "./insertQuery";
 
 describe("InsertQuery class", () => {
@@ -43,8 +42,10 @@ describe("InsertQuery class", () => {
   it("should correct execute the query", () => {
     let qe = createRequestExecuterMock(projectID, dataset);
     let subject: any = new InsertQuery(qe, [{ title: "Another first post", user_id: 1 }], dataset);
-    spyOn(subject["queryExecuter"], "executeRestRequest");
+    spyOn(subject["queryExecuter"], "executeRequest");
     subject.execute();
-    expect(subject["queryExecuter"].executeRestRequest).toHaveBeenLastCalledWith(Methods.POST, subject["records"]);
+    expect(subject["queryExecuter"].executeRequest).toHaveBeenLastCalledWith({
+      action: "insert", records: subject["records"]
+    });
   });
 });

src/api/dataops/queries/insertQuery.ts

@@ -1,5 +1,4 @@
 import { RequestExecuter } from "../../../internal/executer";
-import { Methods } from "../../../internal/requestAdapter";
 import { BaseQuery, QueryAction } from "./baseQuery";
 
 /**
@@ -28,12 +27,4 @@ export class InsertQuery<T, D extends T> extends BaseQuery<T> {
     super(queryExecuter, QueryAction.insert, dataset);
     this.records = records;
   }
-
-  /**
-   * Overload parent execute request to call rest API
-   * @returns {Promise<any>}
-   */
-  public execute(): Promise<D[]> {
-    return this.queryExecuter.executeRestRequest<T, D>(Methods.POST, this.records);
-  }
 }

src/api/dataops/queries/selectQuery.spec.ts

@@ -115,21 +115,13 @@ describe("SelectQuery class", () => {
 
   });
 
-  it("without any params should execute the rest api", () => {
-    let qe = createRequestExecuterMock(projectID, dataset);
-    let subject: any = new SelectQuery(qe, dataset);
-    spyOn(subject["queryExecuter"], "executeRestRequest");
-    subject.execute();
-    expect(subject["queryExecuter"].executeRestRequest).toHaveBeenCalled();
-  });
-
-  it("should execute the rest api if there is any param", () => {
+  it("should correct execute the query", () => {
     let qe = createRequestExecuterMock(projectID, dataset);
     let subject: any = new SelectQuery(qe, dataset);
     subject.fields("id");
-    spyOn(subject["queryExecuter"], "executeQueryRequest");
+    spyOn(subject["queryExecuter"], "executeRequest");
     subject.execute();
-    expect(subject["queryExecuter"].executeQueryRequest).toHaveBeenLastCalledWith(subject.compiledRequest);
+    expect(subject["queryExecuter"].executeRequest).toHaveBeenLastCalledWith(subject.compiledRequest);
   });
 
 });

src/api/dataops/queries/updateQuery.spec.ts

@@ -38,8 +38,8 @@ describe("QueryRequest class", () => {
   it("should correct execute the query", () => {
     let qe = createRequestExecuterMock(projectID, dataset);
     let subject: any = new UpdateQuery(qe, [{ title: "Another first post", user_id: 1 }], dataset);
-    spyOn(subject["queryExecuter"], "executeQueryRequest");
+    spyOn(subject["queryExecuter"], "executeRequest");
     subject.execute();
-    expect(subject["queryExecuter"].executeQueryRequest).toHaveBeenLastCalledWith(subject.compiledRequest);
+    expect(subject["queryExecuter"].executeRequest).toHaveBeenLastCalledWith(subject.compiledRequest);
   });
 });

src/config/config.ts

@@ -5,12 +5,7 @@ export const API = {
     API_KEY: "auth",
   },
   DATA: {
-    ENDPOINT: {
-      /* We are going to use REST API endpoint for create (insert) records and delete records by id(s) */
-      REST: "ds/r",
-      /* Use QUERY endpoint for any queries that have conditions, such as select, update and delete */
-      QUERY: "ds/q",
-    },
+    ENDPOINT: "ds",
   },
   FILES: {
     ENDPOINT: "fs",

src/internal/executer.spec.ts

@@ -12,9 +12,7 @@ describe("QueryExecuter class", () => {
   const dataset = "dataset";
   const projectID = "projectID";
   const restUrl = `${API.PROTOCOL}://${projectID}.${API.HOST}.${API.DOMAIN}:${API.PORT}` +
-    `/${API.DATA.ENDPOINT.REST}/${dataset}`;
-  const queryUrl = `${API.PROTOCOL}://${projectID}.${API.HOST}.${API.DOMAIN}:${API.PORT}` +
-    `/${API.DATA.ENDPOINT.QUERY}/${dataset}`;
+    `/${API.DATA.ENDPOINT}/${dataset}`;
 
   beforeAll( () => {
     clientInit = Promise.resolve();
@@ -45,30 +43,16 @@ describe("QueryExecuter class", () => {
       const url = (executor as any).getUrl();
       expect(url).toEqual(restUrl);
     });
-    it("should use query api endpoint for the query reqest", () => {
-      const url = (executor as any).getUrl(true);
-      expect(url).toEqual(queryUrl);
-    });
   });
 
   describe("when calling", () => {
-    it("executeRestMethod() should call getUrl() method without params", (done) => {
-      reqAdapterMock = requestAdapterMockFactory().genericSuccesfulExecution();
-      const re: any = new RequestExecuter({ projectID } as any, dataset, clientInit, reqAdapterMock, tokenManagerMock);
-      spyOn(re, "getUrl");
-      re.executeRestRequest([]);
-      setTimeout(() => {
-        expect(re.getUrl).toHaveBeenCalledWith();
-        done();
-      }, 10);
-    });
-    it("executeQueryMethod() should call getUrl() method with true", (done) => {
+    it("executeRestMethod() should call getUrl() method", (done) => {
       reqAdapterMock = requestAdapterMockFactory().genericSuccesfulExecution();
       const re: any = new RequestExecuter({ projectID } as any, dataset, clientInit, reqAdapterMock, tokenManagerMock);
       spyOn(re, "getUrl");
-      re.executeQueryRequest({action: "action"});
+      re.executeRequest([]);
       setTimeout(() => {
-        expect(re.getUrl).toHaveBeenCalledWith(true);
+        expect(re.getUrl).toHaveBeenCalled();
         done();
       }, 10);
     });
@@ -79,16 +63,16 @@ describe("QueryExecuter class", () => {
       reqAdapterMock = requestAdapterMockFactory().genericSuccesfulExecution();
       const mockBody = {action: "action"};
       const re = new RequestExecuter({ projectID } as any, dataset, clientInit, reqAdapterMock, tokenManagerMock);
-      await re.executeQueryRequest(mockBody);
-      expect(reqAdapterMock.execute).toHaveBeenCalledWith(queryUrl,
+      await re.executeRequest(mockBody);
+      expect(reqAdapterMock.execute).toHaveBeenCalledWith(restUrl,
         { headers: { Authorization: `Bearer ${validToken}` }, body: mockBody, method: Methods.POST });
     });
 
     it("should wait the system initialization before execute the query", (done) => {
       const defer = deferPromise();
       reqAdapterMock = requestAdapterMockFactory().genericSuccesfulExecution();
       const re = new RequestExecuter({} as any, dataset, defer.promise, reqAdapterMock, tokenManagerMock);
-      re.executeQueryRequest({ action: "action" });
+      re.executeRequest({ action: "action" });
       setTimeout(() => {
         expect(reqAdapterMock.execute).not.toHaveBeenCalled();
         done();
@@ -100,7 +84,7 @@ describe("QueryExecuter class", () => {
       reqAdapterMock = requestAdapterMockFactory().genericSuccesfulExecution();
       const re = new RequestExecuter({} as any, dataset, Promise.reject(initError), reqAdapterMock, tokenManagerMock);
       try {
-        await re.executeQueryRequest({ action: "action" });
+        await re.executeRequest({ action: "action" });
         throw new Error("request execution should have throw an error");
       } catch (error) {
         expect(error).toBe(initError);
@@ -114,7 +98,7 @@ describe("QueryExecuter class", () => {
       reqAdapterMock = requestAdapterMockFactory().failedExecution(serverError);
       const mockBody = {action: "select", params: {} };
       const re = new RequestExecuter({ projectID } as any, dataset, clientInit, reqAdapterMock, tokenManagerMock);
-      re.executeQueryRequest(mockBody).then( () => {
+      re.executeRequest(mockBody).then( () => {
         done.fail("request should have failed");
       }).catch( (err: Error) => {
         expect(err.message).toEqual(serverError);

src/internal/executer.ts

@@ -2,6 +2,7 @@ import { Inject, Injectable } from "injection-js";
 import { ClientInit } from "../api/core/client";
 import { AuthOptions, IAuthOptions, TokenManager } from "../api/core/tokenManager";
 import { DataSetName } from "../api/dataops/dataops.tokens";
+import { QueryAction } from "../api/dataops/queries/baseQuery";
 import { API } from "../config";
 import { Methods, RequestAdapter } from "./requestAdapter";
 
@@ -15,28 +16,30 @@ export class RequestExecuter {
     private tokenManager: TokenManager,
   ) { }
 
-  public async executeRestRequest<T, D>(method = Methods.GET, records?: T[]): Promise<D[]> {
+  public async executeRequest(request: any): Promise<any> {
     await this.systemInit;
     const token = await this.tokenManager.token;
     return this.requestAdapter.execute(
       this.getUrl(),
-      { headers: { Authorization: `Bearer ${token}` }, method, ...(records ? { body: records } : {}) });
-  }
-
-  public async executeQueryRequest(request: any): Promise<any> {
-    await this.systemInit;
-    const token = await this.tokenManager.token;
-    return this.requestAdapter.execute(
-      this.getUrl(true),
-      { headers: { Authorization: `Bearer ${token}` }, body: request, method: Methods.POST },
+      { headers: { Authorization: `Bearer ${token}` }, body: request, method: this.getMethod(request.action) },
     );
   }
 
-  private getUrl(query: boolean = false): string {
+  private getUrl(): string {
     return [
       `${API.PROTOCOL}://${this.config.projectID}.${API.HOST}.${API.DOMAIN}:${API.PORT}`,
-      query ? API.DATA.ENDPOINT.QUERY : API.DATA.ENDPOINT.REST,
+      API.DATA.ENDPOINT,
       this.dataSetName,
     ].join("/");
   }
+
+  private getMethod(action: QueryAction): Methods {
+    switch (action) {
+      default:
+      case QueryAction.insert: return Methods.POST;
+      case QueryAction.delete: return Methods.DELETE;
+      case QueryAction.select: return Methods.GET;
+      case QueryAction.update: return Methods.PATCH;
+    }
+  }
 }