2019-05-17 03:19:49 +00:00
|
|
|
import { get } from '@ember/object';
|
2018-02-08 23:06:10 +00:00
|
|
|
import { assign } from '@ember/polyfills';
|
|
|
|
import { inject as service } from '@ember/service';
|
2020-03-25 12:51:26 +00:00
|
|
|
import { AbortError } from '@ember-data/adapter/error';
|
2018-07-06 20:38:57 +00:00
|
|
|
import queryString from 'query-string';
|
2018-02-08 23:06:10 +00:00
|
|
|
import ApplicationAdapter from './application';
|
2020-03-25 12:51:26 +00:00
|
|
|
import removeRecord from '../utils/remove-record';
|
2018-02-08 23:06:10 +00:00
|
|
|
|
|
|
|
export default ApplicationAdapter.extend({
|
|
|
|
watchList: service(),
|
|
|
|
store: service(),
|
|
|
|
|
2019-05-17 03:19:49 +00:00
|
|
|
ajaxOptions(url, type, options) {
|
2020-03-25 12:51:26 +00:00
|
|
|
const ajaxOptions = this._super(url, type, options);
|
|
|
|
|
|
|
|
// Since ajax has been changed to include query params in the URL,
|
|
|
|
// we have to remove query params that are in the URL from the data
|
|
|
|
// object so they don't get passed along twice.
|
|
|
|
const [newUrl, params] = ajaxOptions.url.split('?');
|
|
|
|
const queryParams = queryString.parse(params);
|
|
|
|
ajaxOptions.url = !params ? newUrl : `${newUrl}?${queryString.stringify(queryParams)}`;
|
|
|
|
Object.keys(queryParams).forEach(key => {
|
|
|
|
delete ajaxOptions.data[key];
|
|
|
|
});
|
|
|
|
|
2019-05-20 18:08:16 +00:00
|
|
|
const abortToken = (options || {}).abortToken;
|
|
|
|
if (abortToken) {
|
|
|
|
delete options.abortToken;
|
2019-05-17 03:19:49 +00:00
|
|
|
|
|
|
|
const previousBeforeSend = ajaxOptions.beforeSend;
|
|
|
|
ajaxOptions.beforeSend = function(jqXHR) {
|
2019-05-20 18:08:16 +00:00
|
|
|
abortToken.capture(jqXHR);
|
2019-05-17 03:19:49 +00:00
|
|
|
if (previousBeforeSend) {
|
|
|
|
previousBeforeSend(...arguments);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2018-02-14 23:37:51 +00:00
|
|
|
|
|
|
|
return ajaxOptions;
|
|
|
|
},
|
|
|
|
|
2020-03-25 12:51:26 +00:00
|
|
|
// Overriding ajax is not advised, but this is a minimal modification
|
|
|
|
// that sets off a series of events that results in query params being
|
|
|
|
// available in handleResponse below. Unfortunately, this is the only
|
|
|
|
// place where what becomes requestData can be modified.
|
|
|
|
//
|
|
|
|
// It's either this weird side-effecting thing that also requires a change
|
|
|
|
// to ajaxOptions or overriding ajax completely.
|
|
|
|
ajax(url, type, options) {
|
|
|
|
const hasParams = hasNonBlockingQueryParams(options);
|
|
|
|
if (!hasParams || type !== 'GET') return this._super(url, type, options);
|
|
|
|
|
|
|
|
const params = { ...options.data };
|
|
|
|
delete params.index;
|
|
|
|
|
|
|
|
return this._super(`${url}?${queryString.stringify(params)}`, type, options);
|
|
|
|
},
|
|
|
|
|
2018-02-12 23:24:15 +00:00
|
|
|
findAll(store, type, sinceToken, snapshotRecordArray, additionalParams = {}) {
|
2018-02-16 02:55:59 +00:00
|
|
|
const params = assign(this.buildQuery(), additionalParams);
|
2018-02-12 23:24:15 +00:00
|
|
|
const url = this.urlForFindAll(type.modelName);
|
|
|
|
|
2018-02-16 02:55:59 +00:00
|
|
|
if (get(snapshotRecordArray || {}, 'adapterOptions.watch')) {
|
2019-03-26 07:46:44 +00:00
|
|
|
params.index = this.watchList.getIndexFor(url);
|
2018-02-12 23:24:15 +00:00
|
|
|
}
|
|
|
|
|
2019-05-20 18:08:16 +00:00
|
|
|
const abortToken = get(snapshotRecordArray || {}, 'adapterOptions.abortToken');
|
2018-02-12 23:24:15 +00:00
|
|
|
return this.ajax(url, 'GET', {
|
2019-05-20 18:08:16 +00:00
|
|
|
abortToken,
|
2018-02-12 23:24:15 +00:00
|
|
|
data: params,
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2018-02-08 23:06:10 +00:00
|
|
|
findRecord(store, type, id, snapshot, additionalParams = {}) {
|
2018-02-16 02:55:59 +00:00
|
|
|
let [url, params] = this.buildURL(type.modelName, id, snapshot, 'findRecord').split('?');
|
|
|
|
params = assign(queryString.parse(params) || {}, this.buildQuery(), additionalParams);
|
2018-02-08 23:06:10 +00:00
|
|
|
|
2018-02-16 02:55:59 +00:00
|
|
|
if (get(snapshot || {}, 'adapterOptions.watch')) {
|
2019-03-26 07:46:44 +00:00
|
|
|
params.index = this.watchList.getIndexFor(url);
|
2018-02-08 23:06:10 +00:00
|
|
|
}
|
|
|
|
|
2019-05-20 18:08:16 +00:00
|
|
|
const abortToken = get(snapshot || {}, 'adapterOptions.abortToken');
|
2018-02-08 23:06:10 +00:00
|
|
|
return this.ajax(url, 'GET', {
|
2019-05-20 18:08:16 +00:00
|
|
|
abortToken,
|
2018-02-08 23:06:10 +00:00
|
|
|
data: params,
|
2018-02-17 02:59:40 +00:00
|
|
|
}).catch(error => {
|
|
|
|
if (error instanceof AbortError) {
|
2018-04-05 23:50:37 +00:00
|
|
|
return;
|
2018-02-17 02:59:40 +00:00
|
|
|
}
|
|
|
|
throw error;
|
2018-02-08 23:06:10 +00:00
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2020-03-25 12:51:26 +00:00
|
|
|
query(store, type, query, snapshotRecordArray, options, additionalParams = {}) {
|
|
|
|
const url = this.buildURL(type.modelName, null, null, 'query', query);
|
|
|
|
let [, params] = url.split('?');
|
|
|
|
params = assign(queryString.parse(params) || {}, this.buildQuery(), additionalParams, query);
|
|
|
|
|
|
|
|
if (get(options, 'adapterOptions.watch')) {
|
|
|
|
// The intended query without additional blocking query params is used
|
|
|
|
// to track the appropriate query index.
|
|
|
|
params.index = this.watchList.getIndexFor(`${url}?${queryString.stringify(query)}`);
|
|
|
|
}
|
|
|
|
|
|
|
|
const abortToken = get(options, 'adapterOptions.abortToken');
|
|
|
|
return this.ajax(url, 'GET', {
|
|
|
|
abortToken,
|
|
|
|
data: params,
|
|
|
|
}).then(payload => {
|
|
|
|
const adapter = store.adapterFor(type.modelName);
|
|
|
|
|
|
|
|
// Query params may not necessarily map one-to-one to attribute names.
|
|
|
|
// Adapters are responsible for declaring param mappings.
|
|
|
|
const queryParamsToAttrs = Object.keys(adapter.queryParamsToAttrs || {}).map(key => ({
|
|
|
|
queryParam: key,
|
|
|
|
attr: adapter.queryParamsToAttrs[key],
|
|
|
|
}));
|
|
|
|
|
|
|
|
// Remove existing records that match this query. This way if server-side
|
|
|
|
// deletes have occurred, the store won't have stale records.
|
|
|
|
store
|
|
|
|
.peekAll(type.modelName)
|
|
|
|
.filter(record =>
|
|
|
|
queryParamsToAttrs.some(
|
|
|
|
mapping => get(record, mapping.attr) === query[mapping.queryParam]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
.forEach(record => {
|
|
|
|
removeRecord(store, record);
|
|
|
|
});
|
|
|
|
|
|
|
|
return payload;
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2019-05-20 18:08:16 +00:00
|
|
|
reloadRelationship(model, relationshipName, options = { watch: false, abortToken: null }) {
|
|
|
|
const { watch, abortToken } = options;
|
2018-02-08 23:06:10 +00:00
|
|
|
const relationship = model.relationshipFor(relationshipName);
|
|
|
|
if (relationship.kind !== 'belongsTo' && relationship.kind !== 'hasMany') {
|
|
|
|
throw new Error(
|
|
|
|
`${relationship.key} must be a belongsTo or hasMany, instead it was ${relationship.kind}`
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
const url = model[relationship.kind](relationship.key).link();
|
|
|
|
let params = {};
|
|
|
|
|
|
|
|
if (watch) {
|
2019-03-26 07:46:44 +00:00
|
|
|
params.index = this.watchList.getIndexFor(url);
|
2018-02-08 23:06:10 +00:00
|
|
|
}
|
|
|
|
|
2018-03-23 01:58:45 +00:00
|
|
|
// Avoid duplicating existing query params by passing them to ajax
|
|
|
|
// in the URL and in options.data
|
2018-02-08 23:06:10 +00:00
|
|
|
if (url.includes('?')) {
|
2018-03-23 01:58:45 +00:00
|
|
|
const paramsInUrl = queryString.parse(url.split('?')[1]);
|
|
|
|
Object.keys(paramsInUrl).forEach(key => {
|
|
|
|
delete params[key];
|
|
|
|
});
|
2018-02-08 23:06:10 +00:00
|
|
|
}
|
|
|
|
|
2018-02-12 23:24:15 +00:00
|
|
|
return this.ajax(url, 'GET', {
|
2019-05-20 18:08:16 +00:00
|
|
|
abortToken,
|
2018-02-08 23:06:10 +00:00
|
|
|
data: params,
|
2018-02-17 02:59:40 +00:00
|
|
|
}).then(
|
|
|
|
json => {
|
2019-03-26 07:46:44 +00:00
|
|
|
const store = this.store;
|
2018-02-27 22:56:44 +00:00
|
|
|
const normalizeMethod =
|
|
|
|
relationship.kind === 'belongsTo'
|
|
|
|
? 'normalizeFindBelongsToResponse'
|
|
|
|
: 'normalizeFindHasManyResponse';
|
|
|
|
const serializer = store.serializerFor(relationship.type);
|
|
|
|
const modelClass = store.modelFor(relationship.type);
|
|
|
|
const normalizedData = serializer[normalizeMethod](store, modelClass, json);
|
|
|
|
store.push(normalizedData);
|
2018-02-17 02:59:40 +00:00
|
|
|
},
|
|
|
|
error => {
|
|
|
|
if (error instanceof AbortError) {
|
|
|
|
return relationship.kind === 'belongsTo' ? {} : [];
|
|
|
|
}
|
|
|
|
throw error;
|
|
|
|
}
|
|
|
|
);
|
2018-02-08 23:06:10 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
handleResponse(status, headers, payload, requestData) {
|
2018-03-28 23:10:09 +00:00
|
|
|
// Some browsers lowercase all headers. Others keep them
|
|
|
|
// case sensitive.
|
|
|
|
const newIndex = headers['x-nomad-index'] || headers['X-Nomad-Index'];
|
2018-02-08 23:06:10 +00:00
|
|
|
if (newIndex) {
|
2019-03-26 07:46:44 +00:00
|
|
|
this.watchList.setIndexFor(requestData.url, newIndex);
|
2018-02-08 23:06:10 +00:00
|
|
|
}
|
2018-02-22 21:21:32 +00:00
|
|
|
|
2018-02-08 23:06:10 +00:00
|
|
|
return this._super(...arguments);
|
|
|
|
},
|
|
|
|
});
|
2020-03-25 12:51:26 +00:00
|
|
|
|
|
|
|
function hasNonBlockingQueryParams(options) {
|
|
|
|
if (!options || !options.data) return false;
|
|
|
|
const keys = Object.keys(options.data);
|
|
|
|
if (!keys.length) return false;
|
|
|
|
if (keys.length === 1 && keys[0] === 'index') return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|