run UDAs

Author: Philip-Carneiro

src/classes/insightsConnection.ts

@@ -19,6 +19,7 @@ import { MetaInfoType, MetaObject, MetaObjectPayload } from "../models/meta";
 import {
   getCurrentToken,
   getHttpsAgent,
+  IToken,
 } from "../services/kdbInsights/codeFlowLogin";
 import { InsightsNode } from "../services/kdbTreeProvider";
 import { GetDataObjectPayload } from "../models/data";
@@ -38,6 +39,7 @@ import { InsightsConfig, InsightsEndpoints } from "../models/config";
 import { convertTimeToTimestamp } from "../utils/dataSource";
 import { ScratchpadRequestBody } from "../models/scratchpad";
 import { StructuredTextResults } from "../models/queryResult";
+import { UDARequestBody } from "../models/uda";
 
 export class InsightsConnection {
   public connected: boolean;
@@ -160,13 +162,15 @@ export class InsightsConnection {
         import: "servicebroker/scratchpad/import/data",
         importSql: "servicebroker/scratchpad/import/sql",
         importQsql: "servicebroker/scratchpad/import/qsql",
+        importUDA: "servicebroker/scratchpad/import/uda",
         reset: "servicebroker/scratchpad/reset",
       },
       serviceGateway: {
         meta: "servicegateway/meta",
         data: "servicegateway/data",
         sql: "servicegateway/qe/sql",
         qsql: "servicegateway/qe/qsql",
+        udaBase: "servicegateway/",
       },
     };
     // uncomment this WHEN the insights version is available
@@ -395,6 +399,157 @@ export class InsightsConnection {
     }
   }
 
+  public async generateToken(): Promise<IToken | undefined> {
+    const token = await getCurrentToken(
+      this.node.details.server,
+      this.node.details.alias,
+      this.node.details.realm || "insights",
+      !!this.node.details.insecure,
+    );
+    if (token === undefined) {
+      tokenUndefinedError(this.connLabel);
+    }
+    return token;
+  }
+
+  public async getUDAQuery(
+    udaReqBody: UDARequestBody,
+  ): Promise<any | undefined> {
+    if (this.connected && this.connEndpoints) {
+      const udaEndpoint =
+        this.connEndpoints.serviceGateway.udaBase +
+        udaReqBody.name.split(".").slice(1).join("/");
+      const udaURL = new url.URL(udaEndpoint, this.node.details.server);
+      const token = await this.generateToken();
+      if (token === undefined) {
+        return undefined;
+      }
+
+      const headers = {
+        Authorization: `Bearer ${token.accessToken}`,
+        Accept: "application/octet-stream",
+        "Content-Type": "application/json",
+      };
+
+      const body = udaReqBody.params;
+
+      const options: AxiosRequestConfig = {
+        method: "post",
+        url: udaURL.toString(),
+        data: body,
+        headers: headers,
+        responseType: "arraybuffer",
+        httpsAgent: getHttpsAgent(this.node.details.insecure),
+      };
+      const results = await window.withProgress(
+        {
+          location: ProgressLocation.Notification,
+          cancellable: false,
+        },
+        async (progress, token) => {
+          token.onCancellationRequested(() => {
+            kdbOutputLog(`User cancelled the Datasource Run.`, "WARNING");
+          });
+
+          progress.report({ message: "Query executing..." });
+
+          return await axios(options)
+            .then((response: any) => {
+              kdbOutputLog(
+                `[Datasource RUN] Status: ${response.status}.`,
+                "INFO",
+              );
+              if (isCompressed(response.data)) {
+                response.data = uncompress(response.data);
+              }
+              return {
+                error: "",
+                arrayBuffer: response.data.buffer
+                  ? response.data.buffer
+                  : response.data,
+              };
+            })
+            .catch((error: any) => {
+              kdbOutputLog(
+                `[Datasource RUN] Status: ${error.response.status}.`,
+                "INFO",
+              );
+              return {
+                error: { buffer: error.response.data },
+                arrayBuffer: undefined,
+              };
+            });
+        },
+      );
+      return results;
+    }
+  }
+
+  public async getUDAScratchpadQuery(
+    udaReqBody: UDARequestBody,
+  ): Promise<any | undefined> {
+    if (this.connected && this.connEndpoints) {
+      const isTableView = udaReqBody.returnFormat === "structuredText";
+      const udaURL = new url.URL(
+        this.connEndpoints.scratchpad.importUDA,
+        this.node.details.server,
+      );
+      const token = await this.generateToken();
+      if (token === undefined) {
+        return undefined;
+      }
+      const username = jwtDecode<JwtUser>(token.accessToken);
+      if (username === undefined || username.preferred_username === "") {
+        invalidUsernameJWT(this.connLabel);
+      }
+
+      const headers = {
+        Authorization: `Bearer ${token.accessToken}`,
+        Username: username.preferred_username,
+        "Content-Type": "application/json",
+      };
+
+      const udaResponse = await window.withProgress(
+        {
+          location: ProgressLocation.Notification,
+          cancellable: false,
+        },
+        async (_progress, token) => {
+          token.onCancellationRequested(() => {
+            kdbOutputLog(`User cancelled the UDA execution.`, "WARNING");
+          });
+
+          const udaRes = await axios
+            .post(udaURL.toString(), udaReqBody, {
+              headers,
+              httpsAgent: getHttpsAgent(this.node.details.insecure),
+            })
+            .then((response: any) => {
+              if (response.data.error) {
+                return response.data;
+              } else {
+                kdbOutputLog(`[UDA] Status: ${response.status}`, "INFO");
+                if (!response.data.error) {
+                  if (isTableView) {
+                    response.data = JSON.parse(
+                      response.data.data,
+                    ) as StructuredTextResults;
+                  }
+                  return response.data;
+                }
+                return response.data;
+              }
+            });
+          return udaRes;
+        },
+      );
+      return udaResponse;
+    } else {
+      this.noConnectionOrEndpoints();
+    }
+    return undefined;
+  }
+
   public async getScratchpadQuery(
     query: string,
     context?: string,
@@ -444,7 +599,7 @@ export class InsightsConnection {
         "Content-Type": "application/json",
       };
 
-      const spReponse = await window.withProgress(
+      const spResponse = await window.withProgress(
         {
           location: ProgressLocation.Notification,
           cancellable: false,
@@ -503,7 +658,7 @@ export class InsightsConnection {
           return spRes;
         },
       );
-      return spReponse;
+      return spResponse;
     } else {
       this.noConnectionOrEndpoints();
     }

src/commands/dataSourceCommand.ts

@@ -50,6 +50,8 @@ import {
   offerConnectAction,
 } from "../utils/core";
 import { ServerType } from "../models/connectionsModels";
+import { retrieveDataTypeByString } from "../utils/uda";
+import { UDARequestBody } from "../models/uda";
 
 export async function addDataSource(): Promise<void> {
   const kdbDataSourcesFolderPath = createKdbDataSourcesFolder();
@@ -161,6 +163,9 @@ export async function runDataSource(
       case "QSQL":
         res = await runQsqlDataSource(fileContent, selectedConnection);
         break;
+      case "UDA":
+        res = await runUDADataSource(fileContent, selectedConnection);
+        break;
       case "SQL":
       default:
         res = await runSqlDataSource(fileContent, selectedConnection);
@@ -179,9 +184,12 @@ export async function runDataSource(
         if (success) {
           const resultCount = typeof res === "string" ? "0" : res.rows.length;
           kdbOutputLog(`[DATASOURCE] Results: ${resultCount} rows`, "INFO");
+        } else if (!success) {
+          res = res.errorMsg ? res.errorMsg : res.error;
         }
+        const connVersion = selectedConnection.insightsVersion ?? 0;
         await writeQueryResultsToView(
-          success ? res : res.error,
+          res,
           query,
           connLabel,
           executorName,
@@ -194,9 +202,13 @@ export async function runDataSource(
             `[DATASOURCE] Results is a string with length: ${res.length}`,
             "INFO",
           );
+        } else {
+          if (res.errorMsg) {
+            res = res.errorMsg;
+          }
         }
         await writeQueryResultsToConsole(
-          success ? res : res.error,
+          res,
           query,
           connLabel,
           executorName,
@@ -243,6 +255,8 @@ export function getSelectedType(fileContent: DataSourceFiles): string {
       return "QSQL";
     case DataSourceTypes.SQL:
       return "SQL";
+    case DataSourceTypes.UDA:
+      return "UDA";
     default:
       throw new Error(`Invalid selectedType: ${selectedType}`);
   }
@@ -411,6 +425,58 @@ export async function runSqlDataSource(
   }
 }
 
+export async function runUDADataSource(
+  fileContent: DataSourceFiles,
+  selectedConn: InsightsConnection,
+): Promise<any> {
+  const UDA = fileContent.dataSource.uda;
+  const returnFormat = ext.isResultsTabVisible ? "structuredText" : "text";
+  if (!UDA) {
+    return { error: "UDA not found" };
+  }
+  if (UDA.name === "") {
+    return { error: "UDA name not found" };
+  }
+
+  const params: { [key: string]: any } = {};
+  const parameterTypes: { [key: string]: any } = {};
+
+  if (UDA.params && UDA.params.length > 0) {
+    UDA.params.forEach((param) => {
+      if (param.isVisible) {
+        params[param.name] = param.value;
+        parameterTypes[param.name] = param.selectedMultiTypeString
+          ? retrieveDataTypeByString(param.selectedMultiTypeString)
+          : param.type;
+      }
+    });
+  }
+  // if (Object.keys(params).length === 0) {
+  //   params["table"] = "nsansUdaTable";
+  //   parameterTypes["table"] = -10;
+  // }
+  const udaReqBody: UDARequestBody = {
+    language: "q",
+    name: UDA.name,
+    parameterTypes,
+    params,
+    returnFormat,
+    sampleFn: "first",
+    sampleSize: 10000,
+  };
+
+  const udaCall = await selectedConn.getUDAQuery(udaReqBody);
+
+  if (udaCall?.error) {
+    return parseError(udaCall.error);
+  } else if (udaCall?.arrayBuffer) {
+    const results = handleWSResults(udaCall.arrayBuffer);
+    return handleScratchpadTableRes(results);
+  } else {
+    return { error: "UDA call failed" };
+  }
+}
+
 export function getQuery(
   fileContent: DataSourceFiles,
   selectedType: string,

src/extensionVariables.ts

@@ -290,6 +290,52 @@ export namespace ext {
         "101": "Unary",
       }),
     ),
+    reverseDataTypes: new Map(
+      Object.entries({
+        Boolean: -1,
+        GUID: -2,
+        Byte: -4,
+        Short: -5,
+        Int: -6,
+        Long: -7,
+        Float: -8,
+        Double: -9,
+        Char: -10,
+        Symbol: -11,
+        Timestamp: -12,
+        Month: -13,
+        Date: -14,
+        DateTime: -15,
+        Timespan: -16,
+        Minute: -17,
+        Second: -18,
+        Time: -19,
+        List: 0,
+        "Boolean List": 1,
+        "GUID List": 2,
+        "Byte List": 4,
+        "Short List": 5,
+        "Int List": 6,
+        "Long List": 7,
+        "Float List": 8,
+        "Double List": 9,
+        String: 10,
+        "Symbol List": 11,
+        "Timestamp List": 12,
+        "Month List": 13,
+        "Date List": 14,
+        "DateTime List": 15,
+        "Timespan List": 16,
+        "Minute List": 17,
+        "Second List": 18,
+        "Time List": 19,
+        "Any Map": 77,
+        Table: 98,
+        Dictionary: 99,
+        Lambda: 100,
+        Unary: 101,
+      }),
+    ),
     listSeparator: [
       ";",
       "",

src/models/config.ts

@@ -26,12 +26,14 @@ export type InsightsEndpoints = {
     import: string;
     importSql: string;
     importQsql: string;
+    importUDA: string;
     reset: string;
   };
   serviceGateway: {
     meta: string;
     data: string;
     sql: string;
     qsql: string;
+    udaBase: string;
   };
 };