updates auth method list and config views to use api service

Author: zofskeez

ui/app/adapters/generated-item-list.js

@@ -8,6 +8,7 @@ import { service } from '@ember/service';
 import { sanitizePath } from 'core/utils/sanitize-path';
 import { encodePath } from 'vault/utils/path-encoding-helpers';
 import { tracked } from '@glimmer/tracking';
+import { getOwner } from '@ember/owner';
 
 export default class GeneratedItemListAdapter extends ApplicationAdapter {
   @service store;
@@ -28,8 +29,10 @@ export default class GeneratedItemListAdapter extends ApplicationAdapter {
     return this.paths.deletePath || '';
   }
 
-  getDynamicApiPath(id) {
-    const result = this.store.peekRecord('auth-method', id);
+  getDynamicApiPath() {
+    const result = getOwner(this)
+      .lookup('route:vault.cluster.access.method')
+      .modelFor('vault.cluster.access.method');
     this.apiPath = result.apiPath;
     return result.apiPath;
   }

ui/app/components/auth-method/configuration.hbs

@@ -0,0 +1,20 @@
+{{!
+  Copyright (c) HashiCorp, Inc.
+  SPDX-License-Identifier: BUSL-1.1
+}}
+
+<div class="box is-fullwidth is-sideless is-paddingless is-marginless">
+  {{#if @method.directLoginLink}}
+    <InfoTableRow @alwaysRender={{true}} @label="UI login link">
+      <Hds::Copy::Snippet @textToCopy={{@method.directLoginLink}} />
+    </InfoTableRow>
+  {{/if}}
+  {{#each this.displayFields as |field|}}
+    <InfoTableRow
+      @alwaysRender={{not (is-empty-value (get @method field))}}
+      @label={{this.label field}}
+      @value={{this.value field}}
+      @formatTtl={{this.isTtl field}}
+    />
+  {{/each}}
+</div>

ui/app/components/auth-method/configuration.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Component from '@glimmer/component';
+import { toLabel } from 'core/helpers/to-label';
+import { get } from '@ember/object';
+
+import type AuthMethodResource from 'vault/resources/auth/method';
+
+interface Args {
+  method: AuthMethodResource;
+}
+export default class AuthMethodConfigurationComponent extends Component<Args> {
+  displayFields = [
+    'type',
+    'path',
+    'description',
+    'accessor',
+    'local',
+    'sealWrap',
+    'config.listingVisibility',
+    'config.defaultLeaseTtl',
+    'config.maxLeaseTtl',
+    'config.tokenType',
+    'config.auditNonHmacRequestKeys',
+    'config.auditNonHmacResponseKeys',
+    'config.passthroughRequestHeaders',
+    'config.allowedResponseHeaders',
+    'config.pluginVersion',
+  ];
+
+  label = (field: string) => {
+    const key = field.replace('config.', '');
+    const label = toLabel([key]);
+    // map specific fields to custom labels
+    return (
+      {
+        listingVisibility: 'Use as preferred UI login method',
+        defaultLeaseTtl: 'Default Lease TTL',
+        maxLeaseTtl: 'Max Lease TTL',
+        auditNonHmacRequestKeys: 'Request keys excluded from HMACing in audit',
+        auditNonHmacResponseKeys: 'Response keys excluded from HMACing in audit',
+        passthroughRequestHeaders: 'Allowed passthrough request headers',
+      }[key] || label
+    );
+  };
+  value = (field: string) => {
+    const { method } = this.args;
+    if (field === 'config.listingVisibility') {
+      return method.config.listingVisibility === 'unauth';
+    }
+    return get(method, field);
+  };
+
+  isTtl = (field: string) => {
+    return ['config.defaultLeaseTtl', 'config.maxLeaseTtl'].includes(field);
+  };
+}

ui/app/resources/auth/method.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { baseResourceFactory } from 'vault/resources/base-factory';
+import { service } from '@ember/service';
+import { supportedTypes } from 'vault/utils/supported-login-methods';
+import engineDisplayData from 'vault/helpers/engines-display-data';
+
+import type { SecretsEngine } from 'vault/secrets/engine';
+import type VersionService from 'vault/services/version';
+import type NamespaceService from 'vault/services/namespace';
+import type { PathInfo } from 'vault/utils/openapi-helpers';
+
+export default class AuthMethodResource extends baseResourceFactory<SecretsEngine>() {
+  @service declare readonly version: VersionService;
+  @service declare readonly namespace: NamespaceService;
+
+  id: string;
+  declare paths: PathInfo;
+
+  constructor(data: SecretsEngine, context: unknown) {
+    super(data, context);
+    // strip trailing slash from path for id since it is used in routing
+    this.id = data.path.replace(/\/$/, '');
+  }
+
+  // namespaces introduced types with a `ns_` prefix for built-in engines
+  // so we need to strip that to normalize the type
+  get methodType() {
+    return this.type.replace(/^ns_/, '');
+  }
+
+  get icon() {
+    // methodType refers to the backend type (e.g., "aws", "azure")
+    const engineData = engineDisplayData(this.methodType);
+    return engineData?.glyph || 'users';
+  }
+
+  get directLoginLink() {
+    const ns = this.namespace.path;
+    const nsQueryParam = ns ? `namespace=${encodeURIComponent(ns)}&` : '';
+    const isSupported = supportedTypes(this.version.isEnterprise).includes(this.methodType);
+    return isSupported
+      ? `${window.origin}/ui/vault/auth?${nsQueryParam}with=${encodeURIComponent(this.path)}`
+      : '';
+  }
+
+  // used when the `auth` prefix is important,
+  // currently only when setting perf mount filtering
+  get apiPath() {
+    return `auth/${this.path}`;
+  }
+
+  get localDisplay() {
+    return this.local ? 'local' : 'replicated';
+  }
+
+  get supportsUserLockoutConfig() {
+    return ['approle', 'ldap', 'userpass'].includes(this.methodType);
+  }
+}

ui/app/resources/base-factory.ts

@@ -3,18 +3,27 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
+import { getOwner, setOwner } from '@ember/owner';
+
+import type Owner from '@ember/owner';
+
 abstract class BaseResource<T> {
   // pass data that the resource should represent (typically from an API response) to constructor
   // object properties will be assigned to class instance
   // extending classes can define getters and additional properties/methods that are required widely across the app
-  constructor(readonly data: T) {
+  constructor(data: T, context?: unknown) {
     Object.assign(this, data) as T;
+    // pass in context (this) of Ember class (route, component etc.) where the resource is being constructed
+    // this will be used to set the owner on the class so that services can be injected (if required)
+    if (context) {
+      setOwner(this, getOwner(context) as Owner);
+    }
   }
 }
 
-// factory that allows for the BaseResource class to be casted to the specific type provided
+// factory that allows for the BaseResource class to be cast to the specific type provided
 // without this the compiler is not aware of the properties set on the class via Object.assign
 // example usage -> export default class SecretsEngineResource extends baseResourceFactory<SecretsEngine>() { ... }
 export function baseResourceFactory<T>() {
-  return BaseResource as new (data: T) => T;
+  return BaseResource as new (data: T, context?: unknown) => T;
 }

ui/app/routes/vault/cluster/access/method.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Route from '@ember/routing/route';
+import { service } from '@ember/service';
+import { supportedManagedAuthBackends } from 'vault/helpers/supported-managed-auth-backends';
+import AuthMethodResource from 'vault/resources/auth/method';
+
+import type ApiService from 'vault/services/api';
+import type PathHelpService from 'vault/services/path-help';
+
+export default class VaultClusterAccessMethodRoute extends Route {
+  @service declare readonly api: ApiService;
+  @service declare readonly pathHelp: PathHelpService;
+
+  async model(params: { path: string }) {
+    const { path } = params;
+    const { auth } = await this.api.sys.internalUiListEnabledVisibleMounts();
+    const methods = this.api
+      .responseObjectToArray(auth, 'path')
+      .map((method) => new AuthMethodResource(method, this));
+    const method = methods.find((m) => m.id === path);
+    // the user could have entered a random path in the URL that doesn't correspond to an existing method
+    if (method) {
+      const supportManaged = supportedManagedAuthBackends();
+      // do not fetch path-help for unmanaged auth types
+      if (!supportManaged.includes(method.methodType)) {
+        method.paths = { apiPath: method.apiPath, paths: [], itemTypes: [] };
+        return method;
+      }
+      return this.pathHelp.getPaths(method.apiPath, path, '', '').then((pathInfo) => {
+        method.paths = pathInfo;
+        return method;
+      });
+    } else {
+      // throw a 404 if the path doesn't match any of the fetched methods
+      throw { httpStatus: 404, path };
+    }
+  }
+}

ui/app/routes/vault/cluster/access/method.ts

@@ -18,14 +18,13 @@ export default Route.extend({
     return this.modelFor('vault.cluster.access.method');
   },
 
-  setupController(controller) {
+  setupController(controller, model) {
     const { section_name: section } = this.paramsFor(this.routeName);
     this._super(...arguments);
     controller.set('section', section);
-    const method = this.modelFor('vault.cluster.access.method');
     controller.set(
       'paths',
-      method.paths.paths.filter((path) => path.navigation)
+      model.paths.paths.filter((path) => path.navigation)
     );
   },
 });

ui/app/routes/vault/cluster/access/method/section.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Route from '@ember/routing/route';
+import { service } from '@ember/service';
+import AuthMethodResource from 'vault/resources/auth/method';
+
+import type ApiService from 'vault/services/api';
+
+export default class VaultClusterAccessMethodsRoute extends Route {
+  @service declare readonly api: ApiService;
+
+  queryParams = {
+    page: {
+      refreshModel: true,
+    },
+    pageFilter: {
+      refreshModel: true,
+    },
+  };
+
+  async model() {
+    const { auth } = await this.api.sys.internalUiListEnabledVisibleMounts();
+    return this.api.responseObjectToArray(auth, 'path').map((method) => new AuthMethodResource(method, this));
+  }
+}