081db3a240
* Update ember-cli to ~3.20 * Remove bad optional-feature * Remove ember-fetch dep * re-install ember-fetch * update model fragments pr * update ember model fragments correct package name * update ember composable helpers to solve array helper error * update ember-concurrency * add back engine dependencies, automatically removed during ember-cli-upgrade * make author-form-options component js file otherwise error * for now comment out withTestWaiter * add eslint-node and fix if not with unless in templates * fix linting for tab index of false is now -1 and add type button to all buttons without types * fix href errors for linting, likely have to come back and fix * using eslint fix flag to fix all this.gets * ember modules codemode removed files that had module twice, will fix in next commit * finish codemode ember-data-codemod needed to rename const model * more this.get removal codemode did not work * cont. removal of this.get * stop mixin rules until figure out how to reconfig them all * smaller eslint ignores * get codemode * testing app small fixes to bring it back after all the changes * small changes to eslint * test removal of getProperties * fix issue with baseKey because value could be unknown needed to add a question mark in nested get * smaller linting fixes * get nested fixes * small linting error fixes * small linting changes * working through more small linting changes * another round of linting modifications * liniting fixes * ember module codemod * quinit dom codemod * angle bracket codemod * discovered that components must have js files * ran all codemods this is all that's left * small changes to fix get needs two object, should not have been using get. * fix issue with one input in form field * fun times with set and onChange from oninput * fix issue with model not being passed through on secret-edit-display * fix issue with yarn run test not working, revert without npm run all * linting and small fix when loading without a selectAuthBackend * fix failing test with ui-wizard issue * fix test failure due to model not being asked for correctly with new changes, probably run into this more. * fix issue with component helper and at props specific to wizard * rename log to clilog due to conflict with new eslint rule * small changes for test failures * component helper at fixes * Revert to old component style something with new one broke this and can't figure it out for now * small fishy smelling test fixes will revisit * small test changes * more small test changes, appears upgrade treats spaces differently * comment out code and test that no longer seems relevant but confirm * clean run on component test though still some potential timing issues on ui-console test * fixing one auth test issue and timing issue on enable-test * small mods * fix this conditional check from upgrade * linting fixes after master merge * package updates using yarn upgrade-interactive * update libraries that did not effect any of the test failures. * update ember truth helpers library * settling tests * Fix ui-panel control group output * fix features selection test failures * Fix auth tests (x-vault-token) * fix shared test * fix issue with data null on backend * Revert "Fix auth tests (x-vault-token)" This reverts commit 89cb174b2f1998efa56d9604d14131415ae65d6f. * Fix auth tests (x-vault-token) without updating this.set * Update redirect-to tests * fix wrapped token test * skip some flaky test * fix issue with href and a tags vs buttons * fix linting * updates to get tests running (#10409) * yarn isntall * increasing resource_class * whoops * trying large * back to xlarge * Fix param issue on transform item routes * test fixes * settle on policies (old) test * fix browserstack test warning and skips of test confirmed worked * Fix redirect-to test * skips * fix transformation test and skip some kmip * Skip tests * Add meep marker to remaining failing tests * Skip test with failing component * rever skip on secret-create test * Skip piece of test that fails due to navigation-input * fix settings test where can and skip in others after confirming * fix circle ci test failures * ssh role settle * Fix navigate-input and add settled to test * Remove extra import * secret cubbyhole and alicloud * Add settled to gcpkms test * settles on redirect to test * Bump browserstack test resource to large * Update browserstack resource size to xlarge * update todos * add back in withTestWaiter * try and fix credentials conditional action added comment instead * Update volatile computed properies to get functions * this step was never reached and we never defined secretType anywhere so I removed * add settled to policy old test * Fix navigate-input on policies and leases * replace ssh test with no var hoping that helps and add settled to other failing tests, unskip console tests * kmip, transit, role test remove a skip and add in settled * fix hover copy button, had to remove some testing functionality * Remove private router service * remove skip on control ssh and ui panel, fix search select by restructuring how to read the error * final bit of working through skipped test * Replace clearNonGlobalModels by linking directly to namespace with href-to * Remove unused var * Fix role-ssh id bug by updating form-field-from-model to form-field-group-loop * Fix transit create id would not update * Update option toggle selector for ssh-role * Fix ssh selector * cleanup pt1 * small clean up * cleanup part2 * Fix computed on pricing-metrics-form * small cleanup based on chelseas comments. Co-authored-by: Chelsea Shaw <chelshaw.dev@gmail.com> Co-authored-by: Sarah Thompson <sthompson@hashicorp.com>
322 lines
11 KiB
JavaScript
322 lines
11 KiB
JavaScript
/*
|
|
This service is used to pull an OpenAPI document describing the
|
|
shape of data at a specific path to hydrate a model with attrs it
|
|
has less (or no) information about.
|
|
*/
|
|
import Model from '@ember-data/model';
|
|
import Service from '@ember/service';
|
|
import { encodePath } from 'vault/utils/path-encoding-helpers';
|
|
import { getOwner } from '@ember/application';
|
|
import { assign } from '@ember/polyfills';
|
|
import { expandOpenApiProps, combineAttributes } from 'vault/utils/openapi-to-attrs';
|
|
import fieldToAttrs from 'vault/utils/field-to-attrs';
|
|
import { resolve, reject } from 'rsvp';
|
|
import { debug } from '@ember/debug';
|
|
import { dasherize, capitalize } from '@ember/string';
|
|
import { singularize } from 'ember-inflector';
|
|
|
|
import generatedItemAdapter from 'vault/adapters/generated-item-list';
|
|
export function sanitizePath(path) {
|
|
// remove whitespace + remove trailing and leading slashes
|
|
return path.trim().replace(/^\/+|\/+$/g, '');
|
|
}
|
|
|
|
export default Service.extend({
|
|
attrs: null,
|
|
dynamicApiPath: '',
|
|
ajax(url, options = {}) {
|
|
let appAdapter = getOwner(this).lookup(`adapter:application`);
|
|
let { data } = options;
|
|
return appAdapter.ajax(url, 'GET', {
|
|
data,
|
|
});
|
|
},
|
|
|
|
getNewModel(modelType, backend, apiPath, itemType) {
|
|
let owner = getOwner(this);
|
|
const modelName = `model:${modelType}`;
|
|
const modelFactory = owner.factoryFor(modelName);
|
|
let newModel, helpUrl;
|
|
// if we have a factory, we need to take the existing model into account
|
|
if (modelFactory) {
|
|
debug(`Model factory found for ${modelType}`);
|
|
newModel = modelFactory.class;
|
|
const modelProto = newModel.proto();
|
|
if (newModel.merged || modelProto.useOpenAPI !== true) {
|
|
return resolve();
|
|
}
|
|
|
|
helpUrl = modelProto.getHelpUrl(backend);
|
|
return this.registerNewModelWithProps(helpUrl, backend, newModel, modelName);
|
|
} else {
|
|
debug(`Creating new Model for ${modelType}`);
|
|
newModel = Model.extend({});
|
|
}
|
|
|
|
// we don't have an apiPath for dynamic secrets
|
|
// and we don't need paths for them yet
|
|
if (!apiPath) {
|
|
helpUrl = newModel.proto().getHelpUrl(backend);
|
|
return this.registerNewModelWithProps(helpUrl, backend, newModel, modelName);
|
|
}
|
|
|
|
// use paths to dynamically create our openapi help url
|
|
// if we have a brand new model
|
|
return this.getPaths(apiPath, backend, itemType)
|
|
.then(pathInfo => {
|
|
const adapterFactory = owner.factoryFor(`adapter:${modelType}`);
|
|
// if we have an adapter already use that, otherwise create one
|
|
if (!adapterFactory) {
|
|
debug(`Creating new adapter for ${modelType}`);
|
|
const adapter = this.getNewAdapter(pathInfo, itemType);
|
|
owner.register(`adapter:${modelType}`, adapter);
|
|
}
|
|
let path, paths;
|
|
// if we have an item we want the create info for that itemType
|
|
paths = itemType ? this.filterPathsByItemType(pathInfo, itemType) : pathInfo.paths;
|
|
const createPath = paths.find(path => path.operations.includes('post') && path.action !== 'Delete');
|
|
path = createPath.path;
|
|
path = path.includes('{') ? path.slice(0, path.indexOf('{') - 1) + '/example' : path;
|
|
if (!path) {
|
|
// TODO: we don't know if path will ever be falsey
|
|
// if it is never falsey we can remove this.
|
|
return reject();
|
|
}
|
|
|
|
helpUrl = `/v1/${apiPath}${path.slice(1)}?help=true` || newModel.proto().getHelpUrl(backend);
|
|
pathInfo.paths = paths;
|
|
newModel = newModel.extend({ paths: pathInfo });
|
|
return this.registerNewModelWithProps(helpUrl, backend, newModel, modelName);
|
|
})
|
|
.catch(err => {
|
|
// TODO: we should handle the error better here
|
|
console.error(err);
|
|
});
|
|
},
|
|
|
|
reducePathsByPathName(pathInfo, currentPath) {
|
|
const pathName = currentPath[0];
|
|
const pathDetails = currentPath[1];
|
|
const displayAttrs = pathDetails['x-vault-displayAttrs'];
|
|
|
|
if (!displayAttrs) {
|
|
return pathInfo;
|
|
}
|
|
|
|
let itemType, itemName;
|
|
if (displayAttrs.itemType) {
|
|
itemType = displayAttrs.itemType;
|
|
let items = itemType.split(':');
|
|
itemName = items[items.length - 1];
|
|
items = items.map(item => dasherize(singularize(item.toLowerCase())));
|
|
itemType = items.join('~*');
|
|
}
|
|
|
|
if (itemType && !pathInfo.itemTypes.includes(itemType)) {
|
|
pathInfo.itemTypes.push(itemType);
|
|
}
|
|
|
|
const operations = [];
|
|
if (pathDetails.get) {
|
|
operations.push('get');
|
|
}
|
|
if (pathDetails.post) {
|
|
operations.push('post');
|
|
}
|
|
if (pathDetails.delete) {
|
|
operations.push('delete');
|
|
}
|
|
if (pathDetails.get && pathDetails.get.parameters && pathDetails.get.parameters[0].name === 'list') {
|
|
operations.push('list');
|
|
}
|
|
|
|
pathInfo.paths.push({
|
|
path: pathName,
|
|
itemType: itemType || displayAttrs.itemType,
|
|
itemName: itemName || pathInfo.itemType || displayAttrs.itemType,
|
|
operations,
|
|
action: displayAttrs.action,
|
|
navigation: displayAttrs.navigation === true,
|
|
param: pathName.includes('{') ? pathName.split('{')[1].split('}')[0] : false,
|
|
});
|
|
|
|
return pathInfo;
|
|
},
|
|
|
|
filterPathsByItemType(pathInfo, itemType) {
|
|
if (!itemType) {
|
|
return pathInfo.paths;
|
|
}
|
|
return pathInfo.paths.filter(path => {
|
|
return itemType === path.itemType;
|
|
});
|
|
},
|
|
|
|
getPaths(apiPath, backend, itemType, itemID) {
|
|
let debugString =
|
|
itemID && itemType
|
|
? `Fetching relevant paths for ${backend} ${itemType} ${itemID} from ${apiPath}`
|
|
: `Fetching relevant paths for ${backend} ${itemType} from ${apiPath}`;
|
|
debug(debugString);
|
|
return this.ajax(`/v1/${apiPath}?help=1`, backend).then(help => {
|
|
const pathInfo = help.openapi.paths;
|
|
let paths = Object.entries(pathInfo);
|
|
|
|
return paths.reduce(this.reducePathsByPathName, {
|
|
apiPath,
|
|
itemType,
|
|
itemTypes: [],
|
|
paths: [],
|
|
itemID,
|
|
});
|
|
});
|
|
},
|
|
|
|
// Makes a call to grab the OpenAPI document.
|
|
// Returns relevant information from OpenAPI
|
|
// as determined by the expandOpenApiProps util
|
|
getProps(helpUrl, backend) {
|
|
// add name of thing you want
|
|
debug(`Fetching schema properties for ${backend} from ${helpUrl}`);
|
|
|
|
return this.ajax(helpUrl, backend).then(help => {
|
|
// paths is an array but it will have a single entry
|
|
// for the scope we're in
|
|
const path = Object.keys(help.openapi.paths)[0]; // do this or look at name
|
|
const pathInfo = help.openapi.paths[path];
|
|
const params = pathInfo.parameters;
|
|
let paramProp = {};
|
|
|
|
// include url params
|
|
if (params) {
|
|
const { name, schema, description } = params[0];
|
|
let label = capitalize(name.split('_').join(' '));
|
|
|
|
paramProp[name] = {
|
|
'x-vault-displayAttrs': {
|
|
name: label,
|
|
group: 'default',
|
|
},
|
|
type: schema.type,
|
|
description: description,
|
|
isId: true,
|
|
};
|
|
}
|
|
|
|
// TODO: handle post endpoints without requestBody
|
|
const props = pathInfo.post
|
|
? pathInfo.post.requestBody.content['application/json'].schema.properties
|
|
: {};
|
|
// put url params (e.g. {name}, {role})
|
|
// at the front of the props list
|
|
const newProps = assign({}, paramProp, props);
|
|
return expandOpenApiProps(newProps);
|
|
});
|
|
},
|
|
|
|
getNewAdapter(pathInfo, itemType) {
|
|
// we need list and create paths to set the correct urls for actions
|
|
let paths = this.filterPathsByItemType(pathInfo, itemType);
|
|
let { apiPath } = pathInfo;
|
|
const getPath = paths.find(path => path.operations.includes('get'));
|
|
|
|
// the action might be "Generate" or something like that so we'll grab the first post endpoint if there
|
|
// isn't one with "Create"
|
|
// TODO: look into a more sophisticated way to determine the create endpoint
|
|
const createPath = paths.find(path => path.action === 'Create' || path.operations.includes('post'));
|
|
const deletePath = paths.find(path => path.operations.includes('delete'));
|
|
|
|
return generatedItemAdapter.extend({
|
|
urlForItem(id, isList, dynamicApiPath) {
|
|
const itemType = getPath.path.slice(1);
|
|
let url;
|
|
id = encodePath(id);
|
|
// the apiPath changes when you switch between routes but the apiPath variable does not unless the model is reloaded
|
|
// overwrite apiPath if dynamicApiPath exist.
|
|
// dynamicApiPath comes from the model->adapter
|
|
if (dynamicApiPath) {
|
|
apiPath = dynamicApiPath;
|
|
}
|
|
// isList indicates whether we are viewing the list page
|
|
// of a top-level item such as userpass
|
|
if (isList) {
|
|
url = `${this.buildURL()}/${apiPath}${itemType}/`;
|
|
} else {
|
|
// build the URL for the show page of a nested item
|
|
// such as a userpass group
|
|
url = `${this.buildURL()}/${apiPath}${itemType}/${id}`;
|
|
}
|
|
|
|
return url;
|
|
},
|
|
|
|
urlForQueryRecord(id, modelName) {
|
|
return this.urlForItem(id, modelName);
|
|
},
|
|
|
|
urlForUpdateRecord(id) {
|
|
const itemType = createPath.path.slice(1, createPath.path.indexOf('{') - 1);
|
|
return `${this.buildURL()}/${apiPath}${itemType}/${id}`;
|
|
},
|
|
|
|
urlForCreateRecord(modelType, snapshot) {
|
|
const { id } = snapshot;
|
|
const path = createPath.path.slice(1, createPath.path.indexOf('{') - 1);
|
|
return `${this.buildURL()}/${apiPath}${path}/${id}`;
|
|
},
|
|
|
|
urlForDeleteRecord(id) {
|
|
const path = deletePath.path.slice(1, deletePath.path.indexOf('{') - 1);
|
|
return `${this.buildURL()}/${apiPath}${path}/${id}`;
|
|
},
|
|
});
|
|
},
|
|
|
|
registerNewModelWithProps(helpUrl, backend, newModel, modelName) {
|
|
return this.getProps(helpUrl, backend).then(props => {
|
|
const { attrs, newFields } = combineAttributes(newModel.attributes, props);
|
|
let owner = getOwner(this);
|
|
newModel = newModel.extend(attrs, { newFields });
|
|
// if our newModel doesn't have fieldGroups already
|
|
// we need to create them
|
|
try {
|
|
let fieldGroups = newModel.proto().fieldGroups;
|
|
if (!fieldGroups) {
|
|
debug(`Constructing fieldGroups for ${backend}`);
|
|
fieldGroups = this.getFieldGroups(newModel);
|
|
newModel = newModel.extend({ fieldGroups });
|
|
}
|
|
} catch (err) {
|
|
// eat the error, fieldGroups is computed in the model definition
|
|
}
|
|
newModel.reopenClass({ merged: true });
|
|
owner.unregister(modelName);
|
|
owner.register(modelName, newModel);
|
|
});
|
|
},
|
|
getFieldGroups(newModel) {
|
|
let groups = {
|
|
default: [],
|
|
};
|
|
let fieldGroups = [];
|
|
newModel.attributes.forEach(attr => {
|
|
// if the attr comes in with a fieldGroup from OpenAPI,
|
|
// add it to that group
|
|
if (attr.options.fieldGroup) {
|
|
if (groups[attr.options.fieldGroup]) {
|
|
groups[attr.options.fieldGroup].push(attr.name);
|
|
} else {
|
|
groups[attr.options.fieldGroup] = [attr.name];
|
|
}
|
|
} else {
|
|
// otherwise just add that attr to the default group
|
|
groups.default.push(attr.name);
|
|
}
|
|
});
|
|
for (let group in groups) {
|
|
fieldGroups.push({ [group]: groups[group] });
|
|
}
|
|
return fieldToAttrs(newModel, fieldGroups);
|
|
},
|
|
});
|