Merge remote-tracking branch 'upstream/master' into ws-folder-servers

Author: isc-bsaviano

package.json

@@ -287,6 +287,10 @@
           "command": "vscode-objectscript.newFile.kpi",
           "when": "false"
         },
+        {
+          "command": "vscode-objectscript.newFile.message",
+          "when": "false"
+        },
         {
           "command": "vscode-objectscript.importLocalFilesServerSide",
           "when": "false"
@@ -654,6 +658,11 @@
           "command": "vscode-objectscript.newFile.dtl",
           "when": "workspaceFolderCount != 0",
           "group": "file"
+        },
+        {
+          "command": "vscode-objectscript.newFile.message",
+          "when": "workspaceFolderCount != 0",
+          "group": "file"
         }
       ]
     },
@@ -1120,6 +1129,11 @@
         "command": "vscode-objectscript.newFile.dtl",
         "title": "Data Transformation"
       },
+      {
+        "category": "ObjectScript",
+        "command": "vscode-objectscript.newFile.message",
+        "title": "Interoperability Message"
+      },
       {
         "category": "ObjectScript",
         "command": "vscode-objectscript.importLocalFilesServerSide",

src/api/index.ts

@@ -111,7 +111,7 @@ export class AtelierAPI {
           if (
             parts.length === 2 &&
             (config("intersystems.servers").has(parts[0].toLowerCase()) ||
-              vscode.workspace.workspaceFolders.find(
+              vscode.workspace.workspaceFolders?.find(
                 (ws) => ws.uri.scheme === "file" && ws.name.toLowerCase() === parts[0].toLowerCase()
               ))
           ) {

src/commands/compile.ts

@@ -92,6 +92,7 @@ export async function importFile(
   ignoreConflict?: boolean,
   skipDeplCheck = false
 ): Promise<any> {
+  if (!file) return;
   const api = new AtelierAPI(file.uri);
   if (!api.active) return;
   if (file.name.split(".").pop().toLowerCase() === "cls" && !skipDeplCheck) {
@@ -261,6 +262,8 @@ export async function loadChanges(files: (CurrentTextFile | CurrentBinaryFile)[]
 }
 
 export async function compile(docs: (CurrentTextFile | CurrentBinaryFile)[], flags?: string): Promise<any> {
+  docs = docs.filter(notNull);
+  if (!docs.length) return;
   const wsFolder = vscode.workspace.getWorkspaceFolder(docs[0].uri);
   const conf = vscode.workspace.getConfiguration("objectscript", wsFolder || docs[0].uri);
   flags = flags || conf.get("compileFlags");
@@ -379,9 +382,7 @@ export async function compileOnly(askFlags = false, document?: vscode.TextDocume
 export async function namespaceCompile(askFlags = false): Promise<any> {
   const api = new AtelierAPI();
   const fileTypes = ["*.CLS", "*.MAC", "*.INC", "*.BAS"];
-  if (!config("conn").active) {
-    throw new Error(`No Active Connection`);
-  }
+  if (!api.active) return;
   const confirm = await vscode.window.showWarningMessage(
     `Compiling all files in namespace ${api.ns} might be expensive. Are you sure you want to proceed?`,
     "Cancel",
@@ -437,18 +438,20 @@ async function importFiles(files: vscode.Uri[], noCompile = false) {
       rateLimiter.call(async () => {
         return vscode.workspace.fs
           .readFile(uri)
-          .then((contentBytes) => {
-            if (isText(uri.path.split("/").pop(), Buffer.from(contentBytes))) {
-              const textFile = currentFileFromContent(uri, new TextDecoder().decode(contentBytes));
-              toCompile.push(textFile);
-              return textFile;
-            } else {
-              return currentFileFromContent(uri, Buffer.from(contentBytes));
+          .then((contentBytes) =>
+            currentFileFromContent(
+              uri,
+              isText(uri.path.split("/").pop(), Buffer.from(contentBytes))
+                ? new TextDecoder().decode(contentBytes)
+                : Buffer.from(contentBytes)
+            )
+          )
+          .then((curFile) => {
+            if (curFile) {
+              if (typeof curFile.content == "string") toCompile.push(curFile); // Only compile text files
+              return importFile(curFile).then(() => outputChannel.appendLine("Imported file: " + curFile.fileName));
             }
-          })
-          .then((curFile) =>
-            importFile(curFile).then(() => outputChannel.appendLine("Imported file: " + curFile.fileName))
-          );
+          });
       })
     )
   );
@@ -460,6 +463,7 @@ async function importFiles(files: vscode.Uri[], noCompile = false) {
 }
 
 export async function importFolder(uri: vscode.Uri, noCompile = false): Promise<any> {
+  if (!(uri instanceof vscode.Uri)) return;
   if (filesystemSchemas.includes(uri.scheme)) return; // Not for server-side URIs
   if ((await vscode.workspace.fs.stat(uri)).type != vscode.FileType.Directory) {
     return importFiles([uri], noCompile);

src/commands/connectFolderToServerNamespace.ts

@@ -50,6 +50,7 @@ export async function connectFolderToServerNamespace(): Promise<void> {
     items.length == 1 && !items[0].detail.startsWith("Currently")
       ? items[0]
       : await vscode.window.showQuickPick(items, { title: "Pick a folder" });
+  if (!pick) return;
   const folder = vscode.workspace.workspaceFolders.find((el) => el.name === pick.label);
   // Get user's choice of server
   const options: vscode.QuickPickOptions = {};

src/commands/newFile.ts

@@ -228,6 +228,7 @@ export enum NewFileType {
   DTL = "Data Transformation",
   Rule = "Business Rule",
   KPI = "Business Intelligence KPI",
+  Message = "Interoperability Message",
 }
 
 interface RuleAssistClasses {
@@ -716,7 +717,10 @@ ClassMethod Transform(source As ${sourceCls}, ByRef target As ${targetCls}) As %
       // Prompt for the production, if required
       let production: string;
       if (Object.keys(ruleAssists).length && assistCls in ruleAssists && ruleAssists[assistCls].hasProduction) {
-        const productions: string[] = await api.getEnsClassList(11).then((data) => data.result.content);
+        const productions: string[] = await api
+          .getEnsClassList(11)
+          .then((data) => data.result.content)
+          .catch(() => []);
         if (productions.length) {
           production = await vscode.window.showQuickPick(productions, {
             ignoreFocusOut: true,
@@ -827,6 +831,108 @@ ClassMethod %OnDashboardAction(pAction As %String, pContext As %ZEN.proxyObject)
   Return $$$OK
 }
 
+}
+`;
+    } else if (type == NewFileType.Message) {
+      // Create the prompt for message type
+      inputSteps.push({
+        type: "quickPick",
+        title: "Pick the message type",
+        items: [
+          {
+            label: "Request",
+            value: "Request",
+          },
+          {
+            label: "Response",
+            value: "Response",
+          },
+        ],
+      });
+
+      // Prompt the user
+      const results = await multiStepInput(inputSteps);
+      if (!results) {
+        return;
+      }
+      cls = results[0];
+      const [, desc, msgType] = results;
+
+      let respClass: string;
+      if (msgType == "Request") {
+        // Prompt the user for the response type
+        const respClasses: vscode.QuickPickItem[] = api
+          ? await api
+              .getEnsClassList(4)
+              .then((data) =>
+                data.result.content.map((label: string) => {
+                  return { label };
+                })
+              )
+              .catch(() => [])
+          : [];
+        if (respClasses.length) {
+          // Use a QuickPick
+          respClass = await new Promise((resolve) => {
+            const quickPick = vscode.window.createQuickPick();
+            quickPick.items = respClasses;
+            quickPick.title =
+              "Pick an optional response class for this request. You may also enter a class name that is not in the list and press 'Enter' to use it. Press 'Escape' to skip.";
+            quickPick.ignoreFocusOut = true;
+            quickPick.onDidAccept(() => {
+              const pickedClass = quickPick.selectedItems[0]?.label ?? quickPick.value.trim();
+              if (!quickPick.selectedItems.length) {
+                // The class name came from the value text, so validate it first
+                const validationMsg = validateClassName(pickedClass);
+                if (validationMsg) {
+                  // The class name is invalid
+                  vscode.window.showErrorMessage(
+                    `${validationMsg}. Please pick a class or enter a valid class name.`,
+                    "Dismiss"
+                  );
+                } else {
+                  // The class name is valid
+                  resolve(pickedClass);
+                  quickPick.hide();
+                }
+              } else {
+                // The class name came from an item so no validation is required
+                resolve(pickedClass);
+                quickPick.hide();
+              }
+            });
+            quickPick.onDidHide(() => {
+              resolve(undefined);
+              quickPick.dispose();
+            });
+            quickPick.show();
+          });
+        } else {
+          // Fall back to using an InputBox
+          respClass = await vscode.window.showInputBox({
+            title: "Enter an optional response class for this request. Press 'Escape' to skip.",
+            ignoreFocusOut: true,
+            validateInput: validateClassName,
+          });
+        }
+      }
+
+      // Generate the file's content
+      clsContent = `
+${typeof desc == "string" ? "/// " + desc.replace(/\n/g, "\n/// ") : ""}
+Class ${cls} Extends (%Persistent, Ens.${msgType})
+{
+${
+  respClass
+    ? `
+/// The corresponding response class for this request
+Parameter RESPONSECLASSNAME As CLASSNAME = "${respClass}";`
+    : ""
+}
+
+/// InterSystems IRIS purges message bodies based on the class when the option to purge message bodies is enabled
+Parameter ENSPURGE As BOOLEAN = 1;
+
 }
 `;
     }