[Spaces] Space-Aware Saved Objects

src/server/saved_objects/client/lib/search_dsl/query_params.js

@@ -27,19 +27,27 @@ function getFieldsForTypes(searchFields, types) {
  *  @param  {Object} type
  *  @param  {String} search
  *  @param  {Array<string>} searchFields
+ *  @param  {Array<object>} extraFilters
  *  @return {Object}
  */
-export function getQueryParams(mappings, type, search, searchFields) {
+export function getQueryParams(mappings, type, search, searchFields, extraFilters) {
   if (!type && !search) {
     return {};
   }
 
   const bool = {};
 
+  const filters = [];
   if (type) {
-    bool.filter = [
-      { term: { type } }
-    ];
+    filters.push({ term: { type } });
+  }
+
+  if (extraFilters) {
+    filters.push(...extraFilters);
+  }
+
+  if (filters.length > 0) {
+    bool.filter = filters;
   }
 
   if (search) {

src/server/saved_objects/client/lib/search_dsl/search_dsl.js

@@ -9,7 +9,8 @@ export function getSearchDsl(mappings, options = {}) {
     search,
     searchFields,
     sortField,
-    sortOrder
+    sortOrder,
+    extraFilters,
   } = options;
 
   if (!type && sortField) {
@@ -20,8 +21,12 @@ export function getSearchDsl(mappings, options = {}) {
     throw Boom.notAcceptable('sortOrder requires a sortField');
   }
 
+  if (extraFilters && !Array.isArray(extraFilters)) {
+    throw Boom.notAcceptable('extraFilters must be an array');
+  }
+
   return {
-    ...getQueryParams(mappings, type, search, searchFields),
+    ...getQueryParams(mappings, type, search, searchFields, extraFilters),
     ...getSortingParams(mappings, type, sortField, sortOrder),
   };
 }

src/server/saved_objects/client/saved_objects_client.js

@@ -107,6 +107,7 @@ export class SavedObjectsClient {
   async create(type, attributes = {}, options = {}) {
     const {
       id,
+      extraBodyProperties = {},
       overwrite = false
     } = options;
 
@@ -120,9 +121,10 @@ export class SavedObjectsClient {
         index: this._index,
         refresh: 'wait_for',
         body: {
+          ...extraBodyProperties,
           type,
           updated_at: time,
-          [type]: attributes
+          [type]: attributes,
         },
       });
 
@@ -167,9 +169,10 @@ export class SavedObjectsClient {
           }
         },
         {
+          ...object.extraBodyProperties,
           type: object.type,
           updated_at: time,
-          [object.type]: object.attributes
+          [object.type]: object.attributes,
         }
       ];
     };
@@ -272,6 +275,7 @@ export class SavedObjectsClient {
       sortField,
       sortOrder,
       fields,
+      extraFilters,
     } = options;
 
     if (searchFields && !Array.isArray(searchFields)) {
@@ -282,6 +286,10 @@ export class SavedObjectsClient {
       throw new TypeError('options.searchFields must be an array');
     }
 
+    if (extraFilters && !Array.isArray(extraFilters)) {
+      throw new TypeError('options.extraFilters must be an array');
+    }
+
     const esOptions = {
       index: this._index,
       size: perPage,
@@ -295,7 +303,8 @@ export class SavedObjectsClient {
           searchFields,
           type,
           sortField,
-          sortOrder
+          sortOrder,
+          extraFilters
         })
       }
     };
@@ -342,7 +351,7 @@ export class SavedObjectsClient {
    *   { id: 'foo', type: 'index-pattern' }
    * ])
    */
-  async bulkGet(objects = []) {
+  async bulkGet(objects = [], options = {}) {
     if (objects.length === 0) {
       return { saved_objects: [] };
     }
@@ -357,8 +366,17 @@ export class SavedObjectsClient {
       }
     });
 
+    const { docs } = response;
+
+    let docsToReturn = docs;
+    if (typeof options.documentFilter === 'function') {
+      docsToReturn = docs.filter(options.documentFilter);
+    }
+
+    const { extraSourceProperties = [] } = options;
+
     return {
-      saved_objects: response.docs.map((doc, i) => {
+      saved_objects: docsToReturn.map((doc, i) => {
         const { id, type } = objects[i];
 
         if (!doc.found) {
@@ -370,13 +388,21 @@ export class SavedObjectsClient {
         }
 
         const time = doc._source.updated_at;
-        return {
+        const savedObject = {
           id,
           type,
           ...time && { updated_at: time },
           version: doc._version,
-          attributes: doc._source[type]
+          attributes: {
+            ...extraSourceProperties
+              .map(s => doc._source[s])
+              .reduce((acc, prop) => ({ ...acc, ...prop }), {}),
+
+            ...doc._source[type],
+          }
         };
+
+        return savedObject;
       })
     };
   }
@@ -388,7 +414,7 @@ export class SavedObjectsClient {
    * @param {string} id
    * @returns {promise} - { id, type, version, attributes }
    */
-  async get(type, id) {
+  async get(type, id, options = {}) {
     const response = await this._callCluster('get', {
       id: this._generateEsId(type, id),
       type: this._type,
@@ -403,14 +429,22 @@ export class SavedObjectsClient {
       throw errors.createGenericNotFoundError();
     }
 
+    const { extraSourceProperties = [] } = options;
+
     const { updated_at: updatedAt } = response._source;
 
     return {
       id,
       type,
       ...updatedAt && { updated_at: updatedAt },
       version: response._version,
-      attributes: response._source[type]
+      attributes: {
+        ...extraSourceProperties
+          .map(s => response._source[s])
+          .reduce((acc, prop) => ({ ...acc, ...prop }), {}),
+
+        ...response._source[type],
+      }
     };
   }
 
@@ -434,8 +468,9 @@ export class SavedObjectsClient {
       ignore: [404],
       body: {
         doc: {
+          ...options.extraBodyProperties,
           updated_at: time,
-          [type]: attributes
+          [type]: attributes,
         }
       },
     });

x-pack/plugins/spaces/index.js

@@ -11,6 +11,7 @@ import { initSpacesApi } from './server/routes/api/v1/spaces';
 import { initSpacesRequestInterceptors } from './server/lib/space_request_interceptors';
 import { mirrorPluginStatus } from '../../server/lib/mirror_plugin_status';
 import mappings from './mappings.json';
+import { spacesSavedObjectsClientWrapper } from './server/lib/saved_objects_client/saved_objects_client_wrapper';
 
 export const spaces = (kibana) => new kibana.Plugin({
   id: 'spaces',
@@ -55,6 +56,9 @@ export const spaces = (kibana) => new kibana.Plugin({
     const config = server.config();
     validateConfig(config, message => server.log(['spaces', 'warning'], message));
 
+    const savedObjectsClientProvider = server.getSavedObjectsClientProvider();
+    savedObjectsClientProvider.addClientWrapper(spacesSavedObjectsClientWrapper);
+
     initSpacesApi(server);
 
     initSpacesRequestInterceptors(server);

x-pack/plugins/spaces/server/lib/saved_objects_client/saved_objects_client_wrapper.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { SpacesSavedObjectsClient } from './spaces_saved_objects_client';
+
+export function spacesSavedObjectsClientWrapper(baseClient, options) {
+  return new SpacesSavedObjectsClient({
+    baseClient,
+    ...options
+  });
+}

x-pack/plugins/spaces/server/lib/saved_objects_client/spaces_saved_objects_client.js

@@ -0,0 +1,132 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export class SpacesSavedObjectsClient {
+  constructor(options) {
+    const {
+      request,
+      baseClient,
+      spaceUrlContext,
+    } = options;
+
+    this.errors = baseClient.errors;
+
+    this._client = baseClient;
+    this._request = request;
+
+    this._spaceUrlContext = spaceUrlContext;
+  }
+
+  async create(type, attributes = {}, options = {}) {
+
+    if (this._isTypeSpaceAware(type)) {
+      options.extraBodyProperties = {
+        ...options.extraBodyProperties,
+        spaceId: await this._getSpaceId()
+      };
+    }
+
+    return await this._client.create(type, attributes, options);
+  }
+
+  async bulkCreate(objects, options = {}) {
+    options.extraBodyProperties = {
+      ...options.extraBodyProperties,
+      spaceId: await this._getSpaceId()
+    };
+
+    return await this._client.bulkCreate(objects, options);
+  }
+
+  async delete(type, id) {
+    return await this._client.delete(type, id);
+  }
+
+  async find(options = {}) {
+    const spaceOptions = {};
+
+    if (this._isTypeSpaceAware(options.type)) {
+      const spaceId = await this._getSpaceId();
+      if (spaceId) {
+        spaceOptions.extraFilters = [{
+          term: {
+            spaceId
+          }
+        }];
+      }
+    }
+
+    return await this._client.find({ ...options, ...spaceOptions });
+  }
+
+  async bulkGet(objects = []) {
+    // ES 'mget' does not support queries, so we have to filter results after the fact.
+    const thisSpaceId = await this._getSpaceId();
+
+    return await this._client.bulkGet(objects, {
+      extraSourceProperties: ['spaceId'],
+      documentFilter: (doc) => {
+        if (!doc.found) return true;
+
+        const { type, spaceId } = doc._source;
+
+        if (this._isTypeSpaceAware(type)) {
+          return spaceId === thisSpaceId;
+        }
+
+        return true;
+      }
+    });
+  }
+
+  async get(type, id) {
+    // ES 'get' does not support queries, so we have to filter results after the fact.
+    let thisSpaceId;
+
+    if (this._isTypeSpaceAware(type)) {
+      thisSpaceId = await this._getSpaceId();
+    }
+
+    const response = await this._client.get(type, id, {
+      extraSourceProperties: ['spaceId']
+    });
+
+    const { spaceId: objectSpaceId } = response.attributes;
+
+    if (objectSpaceId !== thisSpaceId) {
+      throw this._client.errors.createGenericNotFoundError();
+    }
+
+    return response;
+  }
+
+  async update(type, id, attributes, options = {}) {
+    attributes.spaceId = await this._getSpaceId();
+    return await this._client.update(type, id, attributes, options);
+  }
+
+  _isTypeSpaceAware(type) {
+    return type !== 'space';
+  }
+
+  async _getSpaceId() {
+    if (!this._spaceId) {
+      const {
+        saved_objects: spaces = []
+      } =  await this.find({
+        type: 'space',
+        search: `"${this._spaceUrlContext}"`,
+        search_fields: ['urlContext'],
+      });
+
+      if (spaces.length > 0) {
+        this._spaceId = spaces[0].id;
+      }
+    }
+
+    return this._spaceId;
+  }
+}