draft (still buggy)

Author: isc-klu

src/api/index.ts

@@ -38,7 +38,7 @@ export interface ConnectionSettings {
   superserverPort?: number;
   pathPrefix: string;
   ns: string;
-  authorization: Authorization;
+  auth: Authorization;
   docker: boolean;
   dockerService?: string;
 }
@@ -59,7 +59,7 @@ export class AtelierAPI {
   }
 
   public get config(): ConnectionSettings {
-    const { serverName, active = false, https = false, pathPrefix = "", authorization } = this._config;
+    const { serverName, active = false, https = false, pathPrefix = "", auth: authorization } = this._config;
     const ns = this.namespace || this._config.ns;
     const wsKey = this.configName.toLowerCase();
     const host = this.externalServer ? this._config.host : workspaceState.get(wsKey + ":host", this._config.host);
@@ -86,7 +86,7 @@ export class AtelierAPI {
       superserverPort,
       pathPrefix,
       ns,
-      authorization,
+      auth: authorization,
       docker,
       dockerService,
     };
@@ -152,9 +152,9 @@ export class AtelierAPI {
   public setConnSpec(serverName: string, connSpec: IServerSpec): void {
     const {
       webServer: { scheme, host, port, pathPrefix = "" },
-      authorization,
+      auth,
     } = connSpec;
-    this._config.authorization = authorization;
+    this._config.auth = auth;
     this._config.https = scheme == "https";
     this._config.host = host;
     this._config.port = port;
@@ -209,7 +209,7 @@ export class AtelierAPI {
 
   /** Return the key for getting values from connection-specific Maps for this connection */
   private mapKey(): string {
-    const { host, port, authorization } = this.config;
+    const { host, port, auth: authorization } = this.config;
     let pathPrefix = this._config.pathPrefix || "";
     if (pathPrefix.length && !pathPrefix.startsWith("/")) {
       pathPrefix = "/" + pathPrefix;
@@ -252,7 +252,7 @@ export class AtelierAPI {
         host,
         port,
         superserverPort: superServer?.port,
-        authorization,
+        auth: authorization,
         pathPrefix,
         docker: false,
       };
@@ -275,7 +275,7 @@ export class AtelierAPI {
           host,
           port,
           superserverPort: superServer?.port,
-          authorization,
+          auth: authorization,
           pathPrefix,
           docker: true,
           dockerService: conn["docker-compose"].service,
@@ -312,7 +312,7 @@ export class AtelierAPI {
     headers?: any,
     options?: any
   ): Promise<any> {
-    const { active, apiVersion, host, port, authorization, https } = this.config;
+    const { active, apiVersion, host, port, auth: authorization, https } = this.config;
     if (!active || !port || !host) {
       return Promise.reject();
     }
@@ -366,9 +366,7 @@ export class AtelierAPI {
     let authRequest = authRequestMap.get(mapKey);
     if (cookies.length || (method === "HEAD" && !originalPath)) {
       auth = Promise.resolve(cookies);
-      headers["Authorization"] = this.config.authorization.resolved()
-        ? this.config.authorization.httpAuthorizationHeader
-        : "";
+      headers["Authorization"] = this.config.auth.resolved() ? this.config.auth.httpAuthorizationHeader : "";
     } else if (!cookies.length) {
       if (!authRequest) {
         // Recursion point

src/commands/connectFolderToServerNamespace.ts

@@ -80,7 +80,7 @@ export async function connectFolderToServerNamespace(): Promise<void> {
     .serverInfo(false)
     .then((data) => data.result.content.namespaces)
     .catch(async (error) => {
-      if (error?.statusCode == 401 && !api.config.authorization.resolved()) {
+      if (error?.statusCode == 401 && !api.config.auth.resolved()) {
         // Attempt to resolve username and password and try again
         const newSpec = await resolveUsernameAndPassword(api.config.serverName, connSpec);
         if (newSpec) {

src/commands/restDebugPanel.ts

@@ -549,8 +549,7 @@ export class RESTDebugPanel {
               }
             });
             headers["authorization"] =
-              headers["authorization"] ??
-              (api.config.authorization.resolved() ? api.config.authorization.httpAuthorizationHeader : "");
+              headers["authorization"] ?? (api.config.auth.resolved() ? api.config.auth.httpAuthorizationHeader : "");
             const hasBody =
               typeof message.bodyContent == "string" && message.bodyContent != "" && message.bodyType != "No Body";
             if (hasBody) {

src/commands/serverActions.ts

@@ -25,7 +25,7 @@ type ServerAction = { detail: string; id: string; label: string; rawLink?: strin
 export async function serverActions(): Promise<void> {
   const { apiTarget, configName: workspaceFolder } = connectionTarget();
   const api = new AtelierAPI(apiTarget);
-  const { active, host = "", ns = "", https, port = 0, pathPrefix, authorization, docker } = api.config;
+  const { active, host = "", ns = "", https, port = 0, pathPrefix, auth: authorization, docker } = api.config;
   const explorerCount = (await explorerProvider.getChildren()).length;
   if (!explorerCount && (!docker || host === "")) {
     await vscode.commands.executeCommand("ObjectScriptExplorer.focus");

src/commands/webSocketTerminal.ts

@@ -225,7 +225,7 @@ class WebSocketTerminal implements vscode.Pseudoterminal {
     this._hideCursorWrite("\x1b]633;P;HasRichCommandDetection=True\x07");
     // Print the opening message
     this._hideCursorWrite(
-      `\x1b[32mConnected to \x1b[0m\x1b[4m${api.config.host}:${api.config.port}${api.config.pathPrefix}\x1b[0m\x1b[32m as \x1b[0m\x1b[3m${api.config.authorization.username}\x1b[0m\r\n`
+      `\x1b[32mConnected to \x1b[0m\x1b[4m${api.config.host}:${api.config.port}${api.config.pathPrefix}\x1b[0m\x1b[32m as \x1b[0m\x1b[3m${api.config.auth.username}\x1b[0m\r\n`
     );
     // Add event handlers to the socket
     this._socket

src/extension.ts

@@ -254,7 +254,7 @@ export async function resolveConnectionSpec(
           superServer: {
             port: serverForUri.superserverPort,
           },
-          authorization: serverForUri.authorization.clone(),
+          auth: serverForUri.auth.clone(),
           description: `Server for workspace folder '${serverName}'`,
         };
       }
@@ -268,11 +268,11 @@ export async function resolveConnectionSpec(
 }
 
 async function resolvePassword(
-  serverSpec: Pick<serverManager.IServerSpec, "name" | "authorization">,
+  serverSpec: Pick<serverManager.IServerSpec, "name" | "auth">,
   ignoreUnauthenticated = false
 ): Promise<string | undefined> {
-  if (!(serverSpec.authorization.resolved() || ignoreUnauthenticated)) {
-    const scopes = [serverSpec.name, serverSpec.authorization.username || ""];
+  if (!(serverSpec.auth.resolved() || ignoreUnauthenticated)) {
+    const scopes = [serverSpec.name, serverSpec.auth.username || ""];
 
     // Handle Server Manager extension version < 3.8.0
     const account = serverManagerApi.getAccount ? serverManagerApi.getAccount(serverSpec) : undefined;
@@ -289,7 +289,10 @@ async function resolvePassword(
     }
     if (session) {
       // If original spec lacked username use the one obtained from the user by the authprovider (exact case)
-      serverSpec.authorization.resolve(session.accessToken, session.scopes[1]);
+      serverSpec.auth.resolve({
+        username: session.scopes[1],
+        accessToken: session.accessToken,
+      });
       return session.accessToken;
     }
   }
@@ -300,16 +303,16 @@ export async function resolveUsernameAndPassword(
   serverName: string,
   oldSpec: serverManager.IServerSpec
 ): Promise<(serverManager.IServerSpec & { accessToken?: string }) | undefined> {
-  const { authorization: _authorization, ...newSpec } = oldSpec;
+  const { auth: _auth, ...newSpec } = oldSpec;
   newSpec.name = serverName;
-  const authorization = _authorization.clone();
+  const auth = _auth.clone();
 
-  const accessToken = await resolvePassword({ ...newSpec, authorization }, true);
-  if (authorization.resolved()) {
+  const accessToken = await resolvePassword({ ...newSpec, auth }, true);
+  if (auth.resolved()) {
     // Update the connection spec
     resolvedConnSpecs.set(serverName, {
       ...oldSpec,
-      authorization,
+      auth,
       accessToken,
     });
     return resolvedConnSpecs.get(serverName);
@@ -363,7 +366,7 @@ export async function checkConnection(
     _onDidChangeConnection.fire();
   }
   let api = new AtelierAPI(apiTarget, false);
-  const { active, host = "", port = 0, superserverPort = 0, ns = "", authorization } = api.config;
+  const { active, host = "", port = 0, superserverPort = 0, ns = "", auth: authorization } = api.config;
   vscode.commands.executeCommand("setContext", "vscode-objectscript.connectActive", active);
   if (!panel.text) {
     panel.text = `${PANEL_LABEL}`;
@@ -471,7 +474,7 @@ export async function checkConnection(
         let success = false;
         message = "Not Authorized.";
         errorMessage = `Authorization error: Check your credentials in Settings, and that you have sufficient privileges on the /api/atelier web application on ${connInfo}`;
-        if (!api.config.authorization.resolved()) {
+        if (!api.config.auth.resolved()) {
           vscode.window.showErrorMessage(
             `Unauthenticated access rejected by '${api.serverId}'.${
               !api.config.serverName ? " Connection has been disabled." : ""
@@ -515,7 +518,7 @@ export async function checkConnection(
             vscode.window
               .showInputBox({
                 password: true,
-                title: `Not Authorized. Enter password to connect as user '${api.config.authorization.username}' to ${connInfo}`,
+                title: `Not Authorized. Enter password to connect as user '${api.config.auth.username}' to ${connInfo}`,
                 prompt: !api.externalServer ? "If no password is entered the connection will be disabled." : "",
                 ignoreFocusOut: true,
               })
@@ -1978,7 +1981,7 @@ function serverForUri(uri: vscode.Uri): ServerForUri {
     port,
     superserverPort,
     pathPrefix,
-    authorization,
+    auth: authorization,
     ns,
     apiVersion,
     serverVersion,
@@ -1997,7 +2000,7 @@ function serverForUri(uri: vscode.Uri): ServerForUri {
       )
       .get("password") as string | undefined;
     if (password !== undefined) {
-      authorization.resolve(password);
+      authorization.resolve({ accessToken: password });
     }
   }
   return {
@@ -2008,7 +2011,7 @@ function serverForUri(uri: vscode.Uri): ServerForUri {
     port,
     superserverPort,
     pathPrefix,
-    authorization,
+    auth: authorization,
     namespace: ns,
     apiVersion: active ? apiVersion : undefined,
     serverVersion: active ? serverVersion : undefined,

src/providers/FileSystemProvider/FileSystemProvider.ts

@@ -476,10 +476,10 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
       .catch((error) => {
         if (error) {
           if (error.errorText.includes(" #5540:")) {
-            const message = `User '${api.config.authorization.username}' cannot list ${
+            const message = `User '${api.config.auth.username}' cannot list ${
               csp ? `web application '${uri.path}'` : "namespace"
             } contents. If they do not have READ permission on the default code database of the ${api.config.ns.toUpperCase()} namespace then grant it and retry. If the problem remains then execute the following SQL in that namespace:\n\t GRANT EXECUTE ON %Library.RoutineMgr_StudioOpenDialog TO ${
-              api.config.authorization.username
+              api.config.auth.username
             }`;
             handleError(message);
           }
@@ -1006,7 +1006,7 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
   private async _lookup(uri: vscode.Uri, fillInPath?: boolean): Promise<Entry> {
     const api = new AtelierAPI(uri);
     const config = api.config;
-    const rootName = `${config.authorization.username}@${config.host}:${config.port}${config.pathPrefix}/${config.ns.toUpperCase()}`;
+    const rootName = `${config.auth.username}@${config.host}:${config.port}${config.pathPrefix}/${config.ns.toUpperCase()}`;
     let entry: Entry = this.superRoot.entries.get(rootName);
     if (!entry) {
       entry = new Directory(rootName, "");

src/providers/LowCodeEditorProvider.ts

@@ -212,8 +212,8 @@ export class LowCodeEditorProvider implements vscode.CustomTextEditorProvider {
             webviewPanel.webview.postMessage({
               direction: "editor",
               type: "auth",
-              username: api.config.authorization.username,
-              password: api.config.authorization.password,
+              username: api.config.auth.username,
+              password: api.config.auth.password,
             });
           }
           return;

src/utils/index.ts

@@ -923,7 +923,7 @@ export async function getWsServerConnection(minVersion?: string): Promise<vscode
     if (minVersion && lt(config.serverVersion, minVersion)) continue;
     const conn = {
       label: api.connInfo,
-      description: !config.authorization.resolved() ? "Unauthenticated" : config.authorization.username,
+      description: !config.auth.resolved() ? "Unauthenticated" : config.auth.username,
       detail: `http${config.https ? "s" : ""}://${config.host}:${config.port}${config.pathPrefix}`,
       uri: wsFolder.uri,
       ns: api.ns,