@codiac.io/codiac-cli 1.2.126 → 1.2.129

package/lib/cli-common/tenant-contextualizer.js

@@ -0,0 +1,436 @@
+"use strict";
+// COMMENTED OUT BC:  Moved to cli
+// import path = require('path');
+// import chalk = require('chalk');
+// import * as Case from 'case';
+// import { TenantUser, AuthTenant } from '@codiac.io/codiac-common/security/auth-entities';
+// import { isFuture } from "@codiac.io/codiac-common/utilities";
+// import { CodiacClient, CodiacClient as AuthClient } from '@codiac.io/codiac-api-client';
+// import { ProjectConfig, UserContext } from '@codiac.io/codiac-relay-contracts';
+// import { IBetterLogger } from '@codiac.io/codiac-common/IBetterLogger';
+// import { IUserInputProvider, IOutputStyler } from '@codiac.io/codiac-ops-common';
+// import { ProjectContextRepo, LocalOps, DxConstants } from '../ops';
+// import { UserContextLoader, UserContextManager } from '@codiac.io/codiac-ops-enterprise';
+// /** Interfaces with CLI user to establish a tenant context.  */
+// export class TenantContextualizer {
+//   static readonly CODE_FOR_NEW_TENANT="** create new **";
+//   /**
+//    * @param projCfg The In-memory representation of the project's thaulconfig file.
+//    */
+//   constructor(private projCfg: ProjectConfig, private authClient: AuthClient, apiClient: CodiacClient, 
+//     private _projCfgRepo: ProjectContextRepo, 
+//     private ui: IUserInputProvider, private styler: IOutputStyler, private logger: IBetterLogger
+//   ) {
+//     this.userContextLoader = new UserContextLoader(logger);
+//     this.userContextRepo = new UserContextManager(apiClient, logger);
+//   }
+//   private userContextLoader: UserContextLoader; 
+//   private userContextRepo: UserContextManager;  
+//   /** An authenticated user, freshly retrieved during this process. */
+//   private _user: TenantUser|undefined;
+//   /** Ensures that a valid tenant is assigned 
+//    * and the user has a valid tenant contributor token.  */
+//   public async establishTenantContext(currentContext?: UserContext): Promise<UserContext> {
+//     return new Promise<UserContext>(async (resolve,reject) => {
+//       try {
+//         // STEP a:  Load any locally cached user and tenant profiles
+//         /** Defaults to anonymous */
+//         let cachedUserContext = currentContext ?? this.userContextLoader.loadUserContext(this.projCfg.tenantCode);
+//         this.logger.trace(`After loadUserContext(${this.projCfg.tenantCode})`);
+//         // STEP b: Gather up whatever we have stored for user and tenant tokens
+//         let projTenantCode = (this.projCfg.tenantCode && this.projCfg.tenantCode != DxConstants.UNREGISTERED_TENANT_CODE) ? this.projCfg.tenantCode : undefined;
+//         let ultimateUserContext:UserContext|undefined;
+//         this.logger.trace(`Project tenantCode: ${projTenantCode}`);
+//         if (cachedUserContext && projTenantCode) {
+//           ultimateUserContext = ultimateUserContext || this.tryUseCurrentToken(cachedUserContext, projTenantCode);
+//           this.logger.trace(`Ultimate UserContext after tryUseCurrentToken: `, ultimateUserContext);
+//           ultimateUserContext = ultimateUserContext || await this.trySwitchTenant(cachedUserContext, projTenantCode);
+//         }
+//         this.logger.trace(`Cached UserContext before user interaction: `, cachedUserContext);
+//         this.logger.trace(`Ultimate UserContext before user interaction: `, ultimateUserContext);
+//         // Methods below call out for user input.
+//         if (projTenantCode) {
+//           ultimateUserContext = ultimateUserContext || await this.tryAuthenticateUnderTenant(projTenantCode, cachedUserContext?.userName);
+//         } else {  // this is an "else" because we are not going to allow this command to change the project tenant assignment (only add one if it hasnt been assigned).
+//           ultimateUserContext = ultimateUserContext || await this.trySelectFromMyTenants(cachedUserContext);
+//           ultimateUserContext = ultimateUserContext || await this.tryRegisterNewTenant(cachedUserContext);
+//         }
+//         resolve(ultimateUserContext!);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   // ==========================================================================
+//   //                   PRIVATE SUPPORTING METHODS
+//   // ==========================================================================
+//   /** Returns a valid tenant context if the given tenant is already current on the given context and the token isnt expired. */
+//   public tryUseCurrentToken(currentContext: UserContext, tenantCode: string): UserContext|undefined {
+//     if (currentContext.userName != UserContext.ANONYMOUS_USERNAME
+//       && currentContext.currentTenantCode == tenantCode
+//       && currentContext.currentToken
+//       && currentContext.tokenExpiration
+//       && isFuture(currentContext.tokenExpiration)) {
+//           return currentContext;
+//     } else {
+//       return undefined;
+//     }
+//   }
+//   /** Attempts to switch the userContext to a locally cached profile for the given tenant, 
+//    * and if not found, requests a switch from the auth service.
+//    * The current userContext will only be modified if the switch is successfully made. 
+//    * throws is the userContext does not already contain at least one token that will identify the user (regardless of tenant). 
+//    * SIDE-EFFECT:  This may refresh the currentToken on the current user context and cache it to the user context file. */
+//   private async trySwitchTenant(currentContext: UserContext, newTenantCode: string): Promise<UserContext|undefined> {
+//     return new Promise<UserContext|undefined>(async (resolve,reject) => {
+//       try {
+//         let ultimate: UserContext|undefined;
+//         if (currentContext.userName != UserContext.ANONYMOUS_USERNAME) {          
+//           if (currentContext.tokens && currentContext.tokens[newTenantCode] && !this.authClient.isExpired(currentContext.tokens[newTenantCode])) {  // Use the locally cached token 
+//             // We already have an unexpired profile cached for this tenant.  Just make it the current one on the userContext object.
+//             ultimate = currentContext;
+//             ultimate.currentTenantCode = newTenantCode;
+//             ultimate.currentToken = currentContext.tokens[newTenantCode];
+//             ultimate.tokenExpiration = this.authClient.extractTokenExpiration(ultimate.currentToken);
+//             this.userContextRepo.writeUserContext(ultimate); 
+//             this.logger.trace(`Found an unexpired token for [${currentContext.userName}] under tenant: [${newTenantCode}].`);
+//           } else {   // See if the remote service will let us switch
+//             // Get ANY unexpired token to authenticate with 
+//             // (cuz we're gonna talk to the server and have IT switch our tenant)
+//             let token = (!currentContext.tokenExpiration || isFuture(currentContext.tokenExpiration)) ? currentContext.currentToken : undefined;
+//             if (!token && currentContext.tokens) {
+//               // Use one from another profile...  (any unexpired tenant token will do - we just need to identify the user)
+//               for (let tc in currentContext.tokens) {
+//                 if (!this.authClient.isExpired(currentContext.tokens[tc])) {
+//                   token = currentContext.tokens[tc];
+//                   this.logger.trace(`Found an unexpired token for [${currentContext.userName}] under tenant: [${tc}].  Using this to authenticate with the api to attempt a tenant switch.`);
+//                   break;
+//                 }
+//               }
+//             }
+//             if (token) { 
+//               // Ask the server...
+//               this.logger.trace(`Asking api to switch tenant.`);
+//               let switchResult = await this.authClient.switchTenant(token, newTenantCode);
+//               if (switchResult.success && switchResult.output) {
+//                 this._user = switchResult.output.user;  
+//                 ultimate = currentContext;
+//                 ultimate.currentTenantCode = switchResult.output.user.tenantCode;
+//                 ultimate.currentToken = switchResult.output.token;
+//                 ultimate.tokenExpiration = switchResult.output.expiration;
+//                 if (ultimate.currentTenantCode) {
+//                   ultimate.tokens[ultimate.currentTenantCode] = ultimate.currentToken;
+//                 }
+//                 this.userContextRepo.writeUserContext(ultimate); 
+//                 this.logger.trace(`Successfully Switched user context to tenant [${ultimate.currentTenantCode}] via api.`);
+//               } else if (switchResult.output) {
+//                 // We got back a failure but refreshed the token we were using.
+//                 if (token == currentContext.currentToken) /* ie: if we used the token from the original context */ {
+//                   this._user = switchResult.output.user;
+//                   currentContext.currentToken = switchResult.output.token;  // is currentContext passed in byRef?  Will this assignment be honored outside this method?
+//                   currentContext.tokenExpiration = switchResult.output.expiration;
+//                 } else if (this._user) {
+//                   this._user.profiles = switchResult.output.user.profiles;  // The token was from a random tenant, so dont switch the current users tenant, just update its list of tenant profiles.
+//                 } 
+//                 currentContext.tokens[switchResult.output.user.tenantCode] = switchResult.output.token;
+//                 this.userContextRepo.writeUserContext(currentContext); 
+//                 // We arent registered for the project tenant (http 403 ?) <--- We need to prompt for new login creds (they may want to try another user account) OR fail loudly here.
+//                 this.renderNotAMember(currentContext.userName, newTenantCode);
+//               } else {
+//                 // Our current token was invalid or expired,  (http 422 ?) <-- we need to prompt for just password. (NOTE:  That'll be server hit #2 in this sequence)
+//               }
+//             } else {
+//               // We didnt have an unexpired token to use for this.
+//             }
+//           }
+//         }
+//         resolve(ultimate);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Only diff betw this an authenticate is that 
+//    * this method only returns a valid tenant context 
+//    * (whereas authenticate returns a user or tenant context). */
+//   private async tryAuthenticateUnderTenant(tenantCode: string, defaultUserName?: string): Promise<UserContext|undefined> {
+//     return new Promise<UserContext|undefined>(async (resolve,reject) => {
+//       try {
+//         let ultimate: UserContext|undefined;
+//         let newContext = await this.authenticate(tenantCode, defaultUserName);
+//         if (newContext) {
+//           if (newContext.currentTenantCode == tenantCode) {
+//             ultimate = newContext;
+//           } else {
+//             this.renderNotAMember(newContext.userName, tenantCode);
+//           }
+//         }        
+//         resolve(ultimate);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   private async trySelectFromMyTenants(currentContext: UserContext|undefined): Promise<UserContext|undefined> {
+//     return new Promise<UserContext|undefined>(async (resolve,reject) => {
+//       try {
+//         let ultimate: UserContext|undefined;
+//         // Step 1:  GET THE USER'S LIST OF TENANTS (se we can access an updated list of profiles.
+//         //          They gotta be up to date cuz access to that tenant may have been granted just seconds ago).
+//         // We may need to authenticate here.  Or perhaps refresh token.  Where can we store the user from a previous server trip?  do we need to?
+//         if (currentContext)
+//           this.logger.trace("currentContext token BEFORE getUserTenants...", currentContext.currentToken)
+//         else 
+//           this.logger.trace("No currentContext BEFORE getUserTenants")
+//         currentContext = await this.establishPrincipalContext(currentContext);  // shouldnt we do this before we do anything else in this class?
+//         let myTenants: AuthTenant[] = [];
+//         if (currentContext?.currentToken) {
+//           myTenants = await this.getUserTenants(this._user);
+//         }
+//         if (currentContext)
+//           this.logger.trace("currentContext token AFTER getUserTenants...", currentContext.currentToken)
+//         else 
+//           this.logger.trace("No currentContext AFTER getUserTenants")
+//         if (myTenants && myTenants.length > 0) {
+//           let tenantCode = await this.promptToSelectTenant(myTenants);
+//           if (tenantCode) {
+//             if (tenantCode == TenantContextualizer.CODE_FOR_NEW_TENANT) {
+//               tenantCode = undefined;  // this will lead us to createNewTenant while still allowing us to recognize a cancel.
+//             } else {
+//               if (!currentContext) currentContext = await this.authenticate();  // this should never happen - we already did so to get the list of tenant profiles.
+//               if (currentContext) {
+//                 ultimate = await this.trySwitchTenant(currentContext, tenantCode);  // Call server if we dont already have a token for the selected tenant.
+//                 if (ultimate) {
+//                   // Commented out bc:  TenantContextulizer should NOT be creating a proj cfg where there wasnt one. The init command has the sole responsibility there.
+//                   // if (!this.projCfg) this.projCfg = this.createDefaultProjectConfig();  // This is avoiding a corrupted project folder.
+//                   // Update the project config if available
+//                   if (this.projCfg) {
+//                     this.projCfg.tenantCode = tenantCode;
+//                     await this._projCfgRepo.updateProjectConfigFile(this.projCfg);
+//                   }
+//                 }
+//               }
+//             }
+//           } else {
+//             this.cancel();  // user gave up: stop the bus.
+//           }
+//         }
+//         resolve(ultimate);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }  
+//   /** Side effect: Overwrites this._user if it s able to refresh it from the auth api */
+//   private async establishPrincipalContext(context: UserContext|undefined): Promise<UserContext|undefined> {
+//     return new Promise<UserContext|undefined>(async (resolve,reject) => {
+//       try {
+//         if (!this._user) {
+//           if (context && context.userName != UserContext.ANONYMOUS_USERNAME && (!context.tokenExpiration || isFuture(context.tokenExpiration))) {
+//             let refreshResult: {context?: UserContext, user?: TenantUser }|undefined;
+//             try {
+//               refreshResult = await this.userContextRepo.refreshUserContext(context);
+//             } catch (err) {
+//               this.logger.warn(`Failed to refresh your user context, leaving your api token potentially stale, preventing further communications: ${err.message||""}`, err);
+//             }
+//             // ----------------------------------------------------------------------------------
+//             // TODO:  Review this logic for refresh/expiration fails 
+//             //        that should run an authenticate but arent...
+//             // ----------------------------------------------------------------------------------
+//             if (refreshResult) {
+//               if (refreshResult.user) {
+//                 this.logger.debug("Setting this.User from refresh output...")
+//                 this._user = refreshResult.user;
+//                 this.logger.debug(`this._user profile count: ${this._user.profiles.length}`)
+//               }
+//               if (refreshResult.context) {
+//                 this.logger.debug("Setting context from refresh output...");
+//                 context = refreshResult.context;
+//               }
+//             // } else {
+//             //   if (context.currentToken && context.currentTenantCode && context.userName) {
+//             //     // Allow for use while disconnected.
+//             //     // TODO:  retrieve a locally cached user object.
+//             //     this._user = new User(context.currentTenantCode, "", "", "", context.userName);
+//             //     this._user.profiles = [];
+//             //     for (let tenantCode in context.tokens) {
+//             //       this._user.profiles.push(new AccessProfile(tenantCode));
+//             //     }
+//             //     this.logger.warn(`Using an instance of the current user sparsely populated from cache.`);
+//             //   }
+//             }
+//           }
+//           if (!this._user) {
+//             let defaultUserName = (context && context.userName != UserContext.ANONYMOUS_USERNAME) ? context.userName : undefined;
+//             let currentTenantCode = (context && context.currentTenantCode) || undefined;
+//             context = await this.authenticate(currentTenantCode, defaultUserName); 
+//           }
+//         }
+//         resolve(context);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   private async getUserTenants(user: TenantUser|undefined): Promise<AuthTenant[]> {
+//     return new Promise<AuthTenant[]>(async (resolve,reject) => {
+//       try {
+//         let myTenants: AuthTenant[] = [];
+//         this.logger.write(`Retrieving tenants of user [${user?.login || "anonymous"}]`);
+//         let myAcctResult = await this.authClient.whoAmI();
+//         if (myAcctResult.error) throw myAcctResult.error;
+//         if (myAcctResult.output?.profiles && myAcctResult.output?.profiles.length > 0) {
+//           let myProfiles = myAcctResult.output.profiles;
+//           // We're gonna put the tenantCode in place of the name for now cuz that's all that we get with whoami.
+//           // TODO:  Consider storing AuthTenant.name with the AccessProfile entity so we can make it readable without an extra db hit. 
+//           myTenants = myProfiles.map(ap => new AuthTenant(ap.tenantCode, ap.tenantCode));
+//           // If we want the tenant names...
+//           //   let codesCsv = myProfiles.map(p => p.tenantCode).join(",");
+//           //   let criteria: TenantCriteria = { mine: true };  // <----- TODO !!!  (works off current user)  
+//           //   let result = await this.apiClient.tryReadMany(AuthTenant, TenantCriteria, criteria);
+//           //  OR
+//           //   let result = await this.authClient.getMyTenants();
+//           //   this.logger.trace("Result of attempt to get user tenants",result)
+//         }
+//         resolve(myTenants);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Prompts the user to select a tenant from the given list of tenantCodes.  
+//    * Returns undefined if cancelled, and TenantContextualizer.CODE_FOR_NEW_TENANT if "register new" is selected.
+//    * @param tenants List of tenants from which to select.
+//    * @param allowAddNew Inserts an option to add a new tenant.  (NOTE: this method DOES NOT perform the add new action itself!)
+//   */
+//   async promptToSelectTenant(tenants: AuthTenant[], allowAddNew: boolean = true): Promise<string|undefined> {
+//     return new Promise<string|undefined>(async (resolve,reject) => {
+//       try {
+//         let choices = tenants.map(t => { 
+//           return { name: t.name, value: t.code }; 
+//         });
+//         if (allowAddNew) {
+//           choices.push({ name: "(Register new tenant)", value: TenantContextualizer.CODE_FOR_NEW_TENANT});
+//         }
+//         this.logger.notice(`Your project is not assigned to a tenant.`);
+//         this.logger.notice(`Please assign it to one of your organizations or register a new organization...`);
+//         let selected = await this.ui.promptSelect('tenantCode', 'Select a Tenant:', choices);
+//         // let result = await inquirer.prompt({ type: 'list', name: 'tenantCode', message: 'Select a Tenant:', choices: choices});
+//         // let selected: string|undefined = result.tenantCode;
+//         resolve(selected);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   /** Returns a tenant context, a user context, or undefined if operation cancelled.  
+//    * Caches the new user context.
+//    * Throws any exceptions. 
+//    * 
+//    * `unregistered` tenant code gets ignored.
+//    * 
+//    * @param login 
+//    * @param silent (optional: defaults to false) When set to true, suppresses the prompts to confirm the given defaults.  Requires defaultLogin and defaultPassword to be set.  Also requires tenantCode if the current user has more than one tenant profile and it cannot be derived decisively from the current context.  
+//    */
+//   public async authenticate(tenantCode?: string, login?: string, password?: string, silent: boolean = false): Promise<UserContext|undefined> {
+//     return new Promise<UserContext>(async (resolve,reject) => {
+//       try {
+//         let defaults = { u: login, p: password, t: tenantCode };
+//         let newContext: UserContext|undefined;
+//         while (!newContext) {
+//           newContext = undefined;
+//           defaults.t = (defaults.t !== undefined && defaults.t !== DxConstants.UNREGISTERED_TENANT_CODE) ? defaults.t : undefined;
+//           if (!silent) {
+//             this.ui.userMessage(`Please authenticate with Codiac ${(defaults.t !== undefined) ? " under tenant " + this.styler.hilite(defaults.t) : ""} (CTRL-C to cancel)`);
+//             defaults.u = await this.ui.prompt("userName", `Username: `, true, defaults.u);
+//           }
+//           if (defaults.u) {
+//             if (!silent) {
+//               defaults.p = defaults.p ?? await this.ui.promptPassword("password", "Password ");
+//             }
+//             if (defaults.p) {
+//               this.logger.debug(`Authenticating against ${this.authClient!.apiRootUrl}`);
+//               let authResult = await this.authClient!.authenticate(defaults.u, defaults.p, defaults.t);
+//               this.logger.debug("", JSON.stringify(authResult, undefined, '  '));
+//               if (authResult.output) {
+//                 let token = authResult.output.token;
+//                 let userName = authResult.output.user.login;
+//                 let tenantCode = authResult.output.user.tenantCode;
+//                 let exp = authResult.output.expiration;
+//                 // this.passwordLastEntered = password;  // we're gonna need this later if we need to register a new tenant (cuz the tenantRegn endpoint doent support a user token yet.)
+//                 newContext = await this.userContextRepo.saveToUserContext(newContext, userName, token, tenantCode, exp);
+//                 this._user = authResult.output.user;
+//               }
+//               if (authResult.error) {
+//                 throw authResult.error;  
+//               }
+//             }
+//           }
+//           // Dump em if they didnt get fully hydrated by this point.
+//           if (silent && (defaults.u === undefined || defaults.p === undefined)) {
+//             throw new Error(`Cannot authenticate using "silent": both login and password must be provided.`);
+//           }
+//         }
+//         resolve(newContext);
+//       } catch (err) {
+//         reject(err);
+//       }
+//     });
+//   }
+//   private isNullOrEmpty(value: string|undefined): boolean {
+//     return (value == undefined || value == "");
+//   }
+//   async tryRegisterNewTenant(currentContext: UserContext|undefined): Promise<UserContext|undefined> {
+//     return new Promise<UserContext|undefined>(async (resolve,reject) => {
+//       try {
+//         let ultimate:UserContext|undefined;
+//         let tenantName = await this.ui.prompt<string>("tenantName", "Enter the full name of the organization: ", true);
+//         // HACK: We happen to know that the authenticate will have necessarily been run before this was called, 
+//         // and we're keeping the pwd from that run in memory just so we can fire this request.
+//         if (!this._user) {
+//           // Wanna authenticate here?
+//           throw new Error("RegisterTenant failed: No user was provided.");
+//         } else if (!tenantName) {
+//           // this is a null gate - it can never happen bc the prompt is required;
+//           throw new Error("RegisterTenant failed: No tenant name was provided.");
+//         } else {
+//           let createNewUser = this.isNullOrEmpty(currentContext?.currentToken);  // we will have already established the user context
+//           let tenantResult = await this.authClient.registerTenant(tenantName, createNewUser, this._user.login, this._user.password!, undefined, currentContext!.currentToken || this.authClient.authToken);  
+//           if (tenantResult.error) {
+//             throw tenantResult.error;
+//           } else if (tenantResult.success && tenantResult.output) {
+//             let token = this.authClient.authToken!;  // thats a valid force - we will def have one if the register call succeeded 
+//             ultimate = await this.userContextRepo.saveToUserContext(currentContext, this._user.login, token, tenantResult.output.code);
+//             this.projCfg.tenantCode = tenantResult.output.code;
+//             await this._projCfgRepo.updateProjectConfigFile(this.projCfg);
+//           } else {
+//             // ??  Fail?  Is this a valid scenario?
+//             throw new Error("RegisterTenant failed: " + tenantResult.message + tenantResult.error);
+//           }
+//         }
+//         resolve(ultimate);
+//       } catch (err) {
+//         this.logger.debug(`Error attempting to register new tenant: ${err.message||""}${err.response?.data?.message||""}`, (err.toJSON) ? err.toJSON() : err);
+//         reject(err);
+//       }
+//     });
+//   }
+//   cancel() {
+//     throw new Error("Action cancelled. No work was done.");
+//     // this.logger.notice("Action cancelled. No work was done.");
+//     // this.exit();
+//   }
+//   /** logs a user message stating that the current user 
+//    * is not a member of the given tenant,
+//    * with instructions for what to do next.  */
+//   private renderNotAMember(username: string, tenantCode: string): void {
+//     this.logger.notice(`You are currently logged in as '${this.styler.hilite(username)}',`);
+//     this.logger.notice(`but you are not a member of the tenant '${this.styler.hilite(tenantCode)}'.`);
+//     this.logger.notice(`You will need to:`);
+//     this.logger.notice(`  EITHER) Log in as a different user, using...`);
+//     this.logger.notice(`    ${this.styler.hilite("cod login [yourUsername] -p [yourPassword]")},`);
+//     this.logger.notice(`  OR) Cancel and send a request to be added, using...`);
+//     this.logger.notice(`    ${this.styler.hilite(`cod request-access ${tenantCode} --role publisher`)}`);
+//   }
+// }
+//# sourceMappingURL=tenant-contextualizer.js.map

package/lib/cli-common/tenant-contextualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-contextualizer.js","sourceRoot":"","sources":["../../src/cli-common/tenant-contextualizer.ts"],"names":[],"mappings":"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"}

package/lib/cli-common/test/tenant-contextualizer.spec.js

@@ -0,0 +1,143 @@
+"use strict";
+// COMMENTED OUT BC:  Moved to cli
+// import * as path from "path";
+// import "mocha";
+// import "chai";
+// import { expect } from "chai";
+// import { ProjectConfig } from "@codiac.io/codiac-relay-contracts";
+// import { IBetterLogger, LogLevel } from '@codiac.io/codiac-common/IBetterLogger';
+// import { BetterConsoleLogger } from "@codiac.io/codiac-common/better-logger"
+// import { CodiacClient } from "@codiac.io/codiac-api-client";
+// import { LocalOps, ProjectContextRepo, DxConstants, CliEnviro, ProjectEnviro, CliGlobalConfigRepo } from "../../ops";
+// import { MockUi } from "../mock-ui";
+// import { TenantContextualizer } from "../tenant-contextualizer";
+// import { Container } from "inversify";
+// import { INTERFACES } from "@codiac.io/codiac-common";
+// import { cwd } from "process";
+// import { INTERFACES_OPS } from "@codiac.io/codiac-ops-common";
+// import { TtyOutputStyler } from "@codiac.io/cli-tools";
+// export type CliTestContext = {
+//   ioc: Container,
+//   logger: IBetterLogger,
+//   projCfg: ProjectConfig,
+//   codiacVersion: string,
+//   codeRoot: string,
+//   projectRoot: string,
+//   cliConfigDir: string,
+//   projCfgRepo: ProjectContextRepo,
+//   localOps: LocalOps,
+//   apiUrl: string,
+//   apiClient: CodiacClient,
+//   mockUi: MockUi, 
+//   outputStyler: TtyOutputStyler
+// }
+// function harness(): CliTestContext {
+//   let ctx = <CliTestContext>{ };
+//   ctx.ioc = new Container();
+//   ctx.logger = new BetterConsoleLogger({ LogLevelsToShow: [LogLevel.trace, LogLevel.debug, LogLevel.error, LogLevel.warn, LogLevel.detail, LogLevel.detail] });
+//   ctx.projCfg = new ProjectConfig("myTestProj", DxConstants.UNREGISTERED_TENANT_CODE, ctx.projCfg.codeVersion);
+//   ctx.codiacVersion = "0.0.0";
+//   ctx.codeRoot = process.cwd();
+//   ctx.projectRoot = path.join(ctx.codeRoot, "src/test/my-test-proj");
+//   ctx.cliConfigDir = path.join(ctx.codeRoot, "src/test/mock-cli-config");
+//   ctx.projCfgRepo = new ProjectContextRepo({ projectRoot: ctx.projectRoot });
+//   // ctx.cliCfgRepo = new CliGlobalConfigRepo({ cliConfigDir: ctx.cliConfigDir, version: "1.0.1" });
+//   ctx.mockUi = new MockUi();
+//   ctx.outputStyler = new TtyOutputStyler();
+//   ctx.ioc.bind(INTERFACES.IBetterLogger).toConstantValue(ctx.logger);
+//   ctx.ioc.bind(CliEnviro).toConstantValue({ cliConfigDir: cwd(), version: "1.0.1" });
+//   ctx.ioc.bind(ProjectEnviro).toConstantValue({ projectRoot: ctx.projectRoot });
+//   ctx.ioc.bind(ProjectContextRepo).toConstantValue(ctx.projCfgRepo);
+//   ctx.ioc.bind(INTERFACES_OPS.IUserInputProvider).toConstantValue(ctx.mockUi);
+//   ctx.ioc.bind(INTERFACES_OPS.IOutputStyler).toConstantValue(ctx.outputStyler);
+//   ctx.localOps = new LocalOps(ctx.ioc); // , ctx.codiacVersion, ctx.projectRoot, ctx.cfgRepo, ctx.mockUi, ctx.mockUi, ctx.logger)
+//   ctx.apiUrl = "http://localhost:5775/"; // "https://toybox01.codiac.io/api/"; // CodiacClient.DEFAULT_API_URL;
+//   ctx.apiClient = CodiacClient.create(ctx.logger, ctx.apiUrl);
+//   return ctx;
+// }
+// describe("When tenant context is needed on a project without a tenant assigned", () => { 
+//   it("then user chooosing to create new shall register a new tenant", async () => {
+//     return new Promise<void>(async (resolve,reject) => {
+//       try {
+//         let ctx = harness();
+//         let tenCon = new TenantContextualizer(ctx.projCfg, ctx.apiClient, ctx.apiClient, ctx.projCfgRepo, ctx.mockUi, ctx.mockUi, ctx.logger);
+//         ctx.mockUi.setValue("userName", "mark.freydl@codiac.io");
+//         ctx.mockUi.setValue("password", "abc123");
+//         ctx.mockUi.setValue("tenantCode", TenantContextualizer.CODE_FOR_NEW_TENANT);
+//         ctx.mockUi.setValue("tenantName", "Test MCF Tenant Inc.")
+//         let context = await tenCon.establishTenantContext();
+//         console.log(JSON.stringify(context));
+//         expect(ctx.mockUi.responses["tenantCode"]).to.not.equal(undefined, "the contextualizer must prompt for tenantCode");
+//         expect(context.userName).to.equal("mark.freydl@codiac.io", "username must match the username in the original context");
+//         expect(context.currentTenantCode).to.not.equal(undefined, "tenantCode cannot be undefined");
+//         expect(context.currentTenantCode).to.not.equal("cod", "tenantCode must NOT match the original value");
+//         expect(ctx.projCfg.tenantCode).to.equal(context.currentTenantCode, "The new tenant code must be written to the project config instance in memory.")
+//         let fromFile = await ctx.projCfgRepo.readProjectConfig();
+//         expect(fromFile.tenantCode).to.equal(context.currentTenantCode, "The new tenant code must be written to the project config file.")
+//         resolve();
+//         // done();
+//       } catch (err) {
+//         // console.log(err);
+//         // resolve();
+//         reject(err);
+//         // done(err);
+//       }
+//     });
+//   });
+//   it("then user context with a current tenant shall prompt for selection", async () => {
+//     return new Promise<void>(async (resolve,reject) => {
+//       try {
+//         let ctx = harness();
+//         let tenCon = new TenantContextualizer(ctx.projCfg, ctx.apiClient, ctx.apiClient, ctx.projCfgRepo, ctx.mockUi, ctx.mockUi, ctx.logger);
+//         ctx.mockUi.setValue("userName", "mark.freydl@codiac.io");
+//         ctx.mockUi.setValue("password", "abc123");
+//         ctx.mockUi.setValue("tenantCode", "cod")
+//         // mockUi.setValue("tenantName", "Test MCF Tenant Inc.")
+//         let context = await tenCon.establishTenantContext();
+//         console.log(JSON.stringify(context));
+//         expect(ctx.mockUi.responses["tenantCode"]).to.not.equal(undefined, "the contextualizer must prompt for tenantCode");
+//         expect(context.userName).to.equal("mark.freydl@codiac.io", "username must match the username in the original context");
+//         expect(context.currentTenantCode).to.not.equal(undefined, "tenatnCode cannot be undefined");
+//         expect(context.currentTenantCode).to.equal("cod", "tenantCode must match the given value");
+//         resolve();
+//         // done();
+//       } catch (err) {
+//         // console.log(err);
+//         // resolve();
+//         reject(err);
+//         // done(err);
+//       }
+//     });
+//   });
+//   it("Then user context shall be switched to project tenant", async () => {
+//     return new Promise<void>(async (resolve,reject) => {
+//       try {
+//         let ctx = harness();
+//         ctx.projCfg.tenantCode = "bid";
+//         ctx.mockUi.setValue("userName", "mark.freydl@codiac.io");
+//         // ctx.mockUi.setValue("tenantCode", "cod")
+//         // mockUi.setValue("tenantName", "Test MCF Tenant Inc.")
+//         ctx.mockUi.setValue("password", "abc123");
+//         let tenCon = new TenantContextualizer(ctx.projCfg, ctx.apiClient, ctx.apiClient, ctx.projCfgRepo, ctx.mockUi, ctx.mockUi, ctx.logger);
+//         // Make sure User has tokens for each tenant
+//         let storedContext = await tenCon.authenticate("bid", "mark.freydl@codiac.io");
+//         let initialUserContext = await tenCon.authenticate("cod", "mark.freydl@codiac.io");
+//         if (!initialUserContext) expect.fail("Test invalid: Unable to set up an initial user context.");
+//         let context = await tenCon.establishTenantContext();
+//         console.log(JSON.stringify(context));
+//         expect(context.currentTenantCode).to.equal(ctx.projCfg.tenantCode, "User tenantCode must match the project config");
+//         expect(ctx.mockUi.responses["tenantCode"]).to.equal(undefined, "the contextualizer must NOT prompt for tenantCode");
+//         expect(context.userName).to.equal(initialUserContext.userName, "username must match the username in the original context");
+//         expect(context.currentTenantCode).to.not.equal(undefined, "tenantCode cannot be undefined");
+//         resolve();
+//         // done();
+//       } catch (err) {
+//         // console.log(err);
+//         // resolve();
+//         reject(err);
+//         // done(err);
+//       }
+//     });
+//   });
+// });
+//# sourceMappingURL=tenant-contextualizer.spec.js.map

package/lib/cli-common/test/tenant-contextualizer.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-contextualizer.spec.js","sourceRoot":"","sources":["../../../src/cli-common/test/tenant-contextualizer.spec.ts"],"names":[],"mappings":";AAAA,kCAAkC;AAElC,gCAAgC;AAChC,kBAAkB;AAClB,iBAAiB;AACjB,iCAAiC;AAEjC,qEAAqE;AACrE,oFAAoF;AACpF,+EAA+E;AAC/E,+DAA+D;AAC/D,wHAAwH;AAExH,uCAAuC;AACvC,mEAAmE;AACnE,yCAAyC;AACzC,yDAAyD;AACzD,iCAAiC;AACjC,iEAAiE;AACjE,0DAA0D;AAE1D,iCAAiC;AAEjC,oBAAoB;AACpB,2BAA2B;AAC3B,4BAA4B;AAC5B,2BAA2B;AAE3B,sBAAsB;AACtB,yBAAyB;AACzB,0BAA0B;AAE1B,qCAAqC;AACrC,wBAAwB;AACxB,oBAAoB;AACpB,6BAA6B;AAE7B,qBAAqB;AACrB,kCAAkC;AAClC,IAAI;AAGJ,uCAAuC;AACvC,mCAAmC;AAEnC,+BAA+B;AAE/B,kKAAkK;AAClK,kHAAkH;AAClH,iCAAiC;AAEjC,kCAAkC;AAClC,wEAAwE;AACxE,4EAA4E;AAE5E,gFAAgF;AAChF,uGAAuG;AAEvG,+BAA+B;AAC/B,8CAA8C;AAE9C,wEAAwE;AACxE,wFAAwF;AACxF,mFAAmF;AACnF,uEAAuE;AACvE,iFAAiF;AACjF,kFAAkF;AAClF,oIAAoI;AAEpI,kHAAkH;AAClH,iEAAiE;AAGjE,gBAAgB;AAChB,IAAI;AAKJ,4FAA4F;AAE5F,sFAAsF;AACtF,2DAA2D;AAC3D,cAAc;AACd,+BAA+B;AAE/B,iJAAiJ;AAEjJ,oEAAoE;AACpE,qDAAqD;AACrD,uFAAuF;AACvF,oEAAoE;AAEpE,+DAA+D;AAC/D,gDAAgD;AAEhD,+HAA+H;AAC/H,kIAAkI;AAClI,uGAAuG;AACvG,iHAAiH;AAEjH,8JAA8J;AAE9J,oEAAoE;AACpE,6IAA6I;AAE7I,qBAAqB;AACrB,qBAAqB;AACrB,wBAAwB;AACxB,+BAA+B;AAC/B,wBAAwB;AACxB,uBAAuB;AACvB,wBAAwB;AACxB,UAAU;AACV,UAAU;AACV,QAAQ;AAGR,2FAA2F;AAC3F,2DAA2D;AAC3D,cAAc;AACd,+BAA+B;AAE/B,iJAAiJ;AAEjJ,oEAAoE;AACpE,qDAAqD;AACrD,mDAAmD;AACnD,mEAAmE;AACnE,+DAA+D;AAC/D,gDAAgD;AAEhD,+HAA+H;AAC/H,kIAAkI;AAClI,uGAAuG;AACvG,sGAAsG;AAEtG,qBAAqB;AACrB,qBAAqB;AACrB,wBAAwB;AACxB,+BAA+B;AAC/B,wBAAwB;AACxB,uBAAuB;AACvB,wBAAwB;AACxB,UAAU;AACV,UAAU;AACV,QAAQ;AAGR,8EAA8E;AAC9E,2DAA2D;AAC3D,cAAc;AACd,+BAA+B;AAC/B,0CAA0C;AAE1C,oEAAoE;AACpE,sDAAsD;AACtD,mEAAmE;AACnE,qDAAqD;AACrD,iJAAiJ;AAEjJ,uDAAuD;AACvD,yFAAyF;AACzF,8FAA8F;AAC9F,2GAA2G;AAE3G,+DAA+D;AAC/D,gDAAgD;AAEhD,+HAA+H;AAC/H,+HAA+H;AAC/H,sIAAsI;AACtI,uGAAuG;AAEvG,qBAAqB;AACrB,qBAAqB;AACrB,wBAAwB;AACxB,+BAA+B;AAC/B,wBAAwB;AACxB,uBAAuB;AACvB,wBAAwB;AACxB,UAAU;AACV,UAAU;AACV,QAAQ;AAIR,MAAM"}