kuzzle 2.49.1 → 2.50.0-beta.4

package/lib/api/controllers/serverController.js

@@ -1,381 +0,0 @@
-/*
- * Kuzzle, a backend software, self-hostable and ready to use
- * to power modern apps
- *
- * Copyright 2015-2022 Kuzzle
- * mailto: support AT kuzzle.io
- * website: http://kuzzle.io
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-"use strict";
-
-const os = require("os");
-const jsonToYaml = require("json2yaml");
-const packagejson = require("../../../package.json");
-
-const { NativeController } = require("./baseController");
-
-const kerror = require("../../kerror");
-
-/**
- * @class ServerController
- */
-class ServerController extends NativeController {
-  constructor() {
-    super([
-      "adminExists",
-      "capabilities",
-      "getAllStats",
-      "getConfig",
-      "getLastStats",
-      "getStats",
-      "healthCheck",
-      "info",
-      "metrics",
-      "now",
-      "publicApi",
-      "openapi",
-    ]);
-
-    this._info = {
-      elasticsearch: null,
-      redis: null,
-    };
-  }
-
-  /**
-   * Init ServerController
-   * Used to perform asynchronous initialization safely: the funnel will wait
-   * for all controllers to be initialized before accepting requests.
-   *
-   * @returns {Promise}
-   */
-  async init() {
-    const [storageInfo, cacheInfo] = await Promise.all([
-      global.kuzzle.ask("core:storage:public:info:get"),
-      global.kuzzle.ask("core:cache:public:info:get"),
-    ]);
-    this._info.elasticsearch = storageInfo;
-    this._info.redis = cacheInfo;
-  }
-
-  /**
-   * Returns the statistics frame from a date
-   *
-   * @param {Request} request
-   * @returns {Promise<Object>}
-   *
-   * @deprecated
-   */
-  getStats(request) {
-    return global.kuzzle.statistics.getStats(request);
-  }
-
-  /**
-   * Returns the last statistics frame
-   *
-   * @returns {Promise<Object>}
-   *
-   * @deprecated
-   */
-  getLastStats() {
-    return global.kuzzle.statistics.getLastStats();
-  }
-
-  /**
-   * Returns all stored statistics frames
-   *
-   * @returns {Promise<Object>}
-   *
-   * @deprecated
-   */
-  getAllStats() {
-    return global.kuzzle.statistics.getAllStats();
-  }
-
-  /**
-   * Returns the Kuzzle configuration
-   *
-   * @returns {Promise<Object>}
-   */
-  async getConfig() {
-    const config = JSON.parse(JSON.stringify(global.kuzzle.config));
-
-    // Already and more appropriately returned by server:info
-    config.http.routes = undefined;
-
-    // Not a good idea to export Kuzzle's salt, hash algorithm
-    // and default rights
-    config.security = undefined;
-
-    if (config.VAULT_KEY) {
-      config.VAULT_KEY = undefined;
-    }
-
-    return config;
-  }
-
-  /**
-   * Returns the Kuzzle capabilities
-   * @returns {Promise<Object>}
-   */
-  async capabilities() {
-    const config = JSON.parse(JSON.stringify(global.kuzzle.config));
-    const publicApi = await this.publicApi();
-    const services = {};
-    const plugins = {};
-
-    for (const plugin of config.plugins.common.include) {
-      plugins[plugin] = {
-        version: packagejson.dependencies[plugin],
-      };
-    }
-
-    for (const [name, info] of Object.entries(config.services)) {
-      if (info.backend !== undefined) {
-        services[name] = {
-          backend: info.backend,
-          version: this._info[info.backend].version,
-        };
-      }
-    }
-
-    return {
-      limits: config.limits,
-      plugins: plugins,
-      routes: publicApi,
-      services: services,
-      version: config.version,
-    };
-  }
-  /**
-   * Checks if an admin user Exists
-   *
-   * @returns {Promise<Object>}
-   */
-  async adminExists() {
-    const exists = await global.kuzzle.ask("core:security:user:admin:exist");
-
-    return { exists };
-  }
-
-  /**
-   * @returns {Promise<Object>}
-   */
-  async now() {
-    return { now: Date.now() };
-  }
-
-  /**
-   * @returns {Promise<Object>}
-   */
-  async healthCheck(request) {
-    const getServiceUnavailableError = (err) =>
-      kerror.get("core", "fatal", "service_unavailable", err);
-    const result = { services: {}, status: "green" };
-
-    let services;
-    if (typeof request.input.args.services === "string") {
-      // @deprecated Should be replaced with request.getArray('services')
-      services = request.getArrayLegacy("services");
-    }
-    if (!services || services.includes("internalCache")) {
-      try {
-        await global.kuzzle.ask("core:cache:internal:info:get");
-        result.services.internalCache = "green";
-      } catch (error) {
-        request.setError(getServiceUnavailableError(error));
-        result.services.internalCache = "red";
-        result.status = "red";
-      }
-    }
-    if (!services || services.includes("memoryStorage")) {
-      try {
-        await global.kuzzle.ask("core:cache:public:info:get");
-        result.services.memoryStorage = "green";
-      } catch (error) {
-        request.setError(getServiceUnavailableError(error));
-        result.services.memoryStorage = "red";
-        result.status = "red";
-      }
-    }
-    if (!services || services.includes("storageEngine")) {
-      try {
-        const response = await global.kuzzle.ask(
-          "core:storage:public:info:get",
-        );
-
-        if (response.status !== "yellow" && response.status !== "green") {
-          throw new Error(`ElasticSearch is down: ${JSON.stringify(response)}`);
-        }
-
-        result.services.storageEngine = "green";
-      } catch (error) {
-        request.setError(getServiceUnavailableError(error));
-        result.services.storageEngine = "red";
-        result.status = "red";
-      }
-    }
-    return result;
-  }
-
-  /**
-   * @returns {Promise<Object>}
-   */
-  async info() {
-    const response = {
-      kuzzle: {
-        api: {
-          routes: {},
-        },
-        application: {},
-        memoryUsed: process.memoryUsage().rss,
-        nodeVersion: process.version,
-        plugins: {},
-        system: {
-          cpus: os.cpus(),
-          memory: {
-            free: os.freemem(),
-            total: os.totalmem(),
-          },
-        },
-        uptime: `${process.uptime()}s`,
-        version: global.kuzzle.config.version,
-      },
-      services: {},
-    };
-
-    const kuzzleApi = this._buildApiDefinition(
-      global.kuzzle.funnel.controllers,
-      global.kuzzle.config.http.routes,
-    );
-    const pluginsApi = this._buildApiDefinition(
-      global.kuzzle.pluginsManager.controllers,
-      global.kuzzle.pluginsManager.routes,
-    );
-    const apiDefinition = Object.assign({}, kuzzleApi, pluginsApi);
-
-    // @todo kuzzle.api should contain the apiDefinition directly
-    response.kuzzle.api.routes = apiDefinition;
-
-    response.kuzzle.plugins =
-      global.kuzzle.pluginsManager.getPluginsDescription();
-
-    response.kuzzle.application =
-      global.kuzzle.pluginsManager.application.info();
-
-    response.services = {
-      internalCache: await global.kuzzle.ask("core:cache:internal:info:get"),
-      internalStorage: await global.kuzzle.ask("core:storage:private:info:get"),
-      memoryStorage: await global.kuzzle.ask("core:cache:public:info:get"),
-      publicStorage: await global.kuzzle.ask("core:storage:public:info:get"),
-    };
-
-    return {
-      serverInfo: response,
-    };
-  }
-
-  async publicApi() {
-    const kuzzleApi = this._buildApiDefinition(
-      global.kuzzle.funnel.controllers,
-      global.kuzzle.config.http.routes,
-    );
-    const pluginsApi = this._buildApiDefinition(
-      global.kuzzle.pluginsManager.controllers,
-      global.kuzzle.pluginsManager.routes,
-    );
-
-    return { ...kuzzleApi, ...pluginsApi };
-  }
-
-  async openapi(request) {
-    const format = request.getString("format", "json");
-    const scope = request.getString("scope", "kuzzle");
-
-    let definition;
-
-    if (scope === "kuzzle") {
-      definition = await global.kuzzle.ask("core:api:openapi:kuzzle");
-    } else if (scope === "app") {
-      definition = await global.kuzzle.ask("core:api:openapi:app");
-    } else {
-      throw kerror.get("api", "assert", "unexpected_argument", scope, [
-        "kuzzle",
-        "app",
-      ]);
-    }
-
-    request.response.configure({
-      format: "raw",
-      headers: { "Content-Type": `application/${format}` },
-    });
-
-    return format === "json" ? definition : jsonToYaml.stringify(definition);
-  }
-
-  /**
-   * Fetches and returns Kuzzle core metrics
-   * @returns {Promise<Object>}
-   */
-  async metrics() {
-    return {
-      api: await global.kuzzle.ask("kuzzle:api:funnel:metrics"),
-      network: await global.kuzzle.ask("core:network:router:metrics"),
-      realtime: await global.kuzzle.ask("core:realtime:hotelClerk:metrics"),
-    };
-  }
-
-  _buildApiDefinition(controllers, httpRoutes) {
-    const apiDefinition = {};
-
-    for (const [name, controller] of controllers.entries()) {
-      const actionList = {};
-
-      for (const action of controller._actions) {
-        actionList[action] = { action, controller: name };
-
-        // resolve associated http route for each actions
-        const routes = httpRoutes.filter((route) => {
-          return (
-            (route.controller === name ||
-              (name === "memoryStorage" && route.controller === "ms")) &&
-            route.action === action
-          );
-        });
-
-        for (const route of routes) {
-          if (!actionList[action].http) {
-            actionList[action].http = [];
-          }
-
-          actionList[action].http.push({
-            path: route.path,
-            url: route.path,
-            verb: route.verb.toUpperCase(),
-          });
-        }
-      }
-
-      if (Object.keys(actionList).length > 0) {
-        apiDefinition[name] = actionList;
-      }
-    }
-
-    return apiDefinition;
-  }
-}
-
-module.exports = ServerController;

package/lib/api/documentExtractor.js

@@ -1,309 +0,0 @@
-/*
- * Kuzzle, a backend software, self-hostable and ready to use
- * to power modern apps
- *
- * Copyright 2015-2022 Kuzzle
- * mailto: support AT kuzzle.io
- * website: http://kuzzle.io
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-"use strict";
-
-const kerror = require("../kerror");
-
-const assertionError = kerror.wrap("api", "assert");
-
-const extractors = [
-  {
-    methods: {
-      extractFromRequest: (request) => [
-        {
-          _id: request.input.args._id,
-          _source: request.input.body.fields,
-        },
-      ],
-      extractFromResult: (request) => [request.result],
-      insertInRequest: ([documents], request) => {
-        request.input.args._id = documents._id;
-        request.input.body.fields = documents._source;
-        return request;
-      },
-      insertInResult: ([document], request) => {
-        request.setResult(document, { status: request.status });
-        return request;
-      },
-    },
-    targets: ["deleteFields"],
-  },
-  {
-    methods: {
-      extractFromRequest: (request) => [{ _id: request.input.args._id }],
-      extractFromResult: (request) => [request.result],
-      insertInRequest: (documents, request) => {
-        request.input.args._id = documents[0] && documents[0]._id;
-        return request;
-      },
-      insertInResult: (documents, request) => {
-        request.setResult(documents[0], { status: request.status });
-        return request;
-      },
-    },
-    targets: ["delete", "get", "exists"],
-  },
-  {
-    methods: {
-      extractFromRequest: (request) => {
-        let ids = [];
-        if (
-          request.input.body &&
-          request.input.body.ids &&
-          Object.keys(request.input.body.ids).length
-        ) {
-          ids = request.input.body.ids;
-        } else if (request.input.args.ids) {
-          if (Array.isArray(request.input.args.ids)) {
-            ids = request.input.args.ids;
-          } else if (typeof request.input.args.ids === "string") {
-            // @deprecated Should be replaced with request.getArray('ids')
-            ids = request.getArrayLegacy("ids");
-          } else {
-            throw assertionError.get(
-              "invalid_type",
-              request.input.args.ids,
-              "Array or String",
-            );
-          }
-        }
-        return ids.map((_id) => ({ _id }));
-      },
-      extractFromResult: (request) => {
-        if (request.input.action === "mGet") {
-          return request.result.successes;
-        }
-
-        const documents = [];
-
-        for (let it = 0; it < request.result.successes.length; it++) {
-          documents.push({ _id: request.result.successes[it] });
-        }
-
-        return documents;
-      },
-      insertInRequest: (documents, request) => {
-        if (request.input.body && Object.keys(request.input.body).length) {
-          request.input.body.ids = documents.map((document) => document._id);
-        } else {
-          request.input.args.ids = documents.map((document) => document._id);
-        }
-        return request;
-      },
-      insertInResult: (documents, request) => {
-        if (request.input.action === "mGet") {
-          request.setResult(
-            {
-              errors: request.result.errors,
-              successes: documents,
-            },
-            {
-              status: request.status,
-            },
-          );
-
-          return request;
-        }
-
-        const result = {
-          errors: request.result.errors,
-          successes: [],
-        };
-
-        for (let it = 0; it < documents.length; it++) {
-          result.successes.push(documents[it]._id);
-        }
-
-        request.setResult(result, { status: request.status });
-
-        return request;
-      },
-    },
-    targets: ["mDelete", "mGet", "mExists"],
-  },
-  {
-    methods: {
-      extractFromRequest: (request) => {
-        const documents = [];
-
-        for (let it = 0; it < request.input.body.documents.length; it++) {
-          const document = request.input.body.documents[it];
-
-          if (request.input.action === "mUpsert") {
-            documents.push({
-              _id: document._id,
-              _source: document.changes,
-            });
-          } else {
-            documents.push({ _id: document._id, _source: document.body });
-          }
-        }
-
-        return documents;
-      },
-      extractFromResult: (request) => request.result.successes,
-      insertInRequest: (documents, request) => {
-        const tmpDocuments = request.input.body.documents;
-
-        request.input.body.documents = [];
-
-        for (let it = 0; it < documents.length; it++) {
-          const document = documents[it];
-
-          if (request.input.action === "mUpsert") {
-            request.input.body.documents.push({
-              _id: document._id,
-              changes: document._source,
-              default: tmpDocuments[it].default,
-            });
-          } else {
-            request.input.body.documents.push({
-              _id: document._id,
-              body: document._source,
-            });
-          }
-        }
-
-        return request;
-      },
-      insertInResult: (documents, request) => {
-        const result = {
-          errors: request.result.errors,
-          successes: documents,
-        };
-
-        request.setResult(result, { status: request.status });
-
-        return request;
-      },
-    },
-    targets: [
-      "mCreate",
-      "mCreateOrReplace",
-      "mReplace",
-      "mUpdate",
-      "updateByQuery",
-      "mUpsert",
-    ],
-  },
-  {
-    methods: {
-      extractFromRequest: null, // not eligible for search queries
-      extractFromResult: (request) => {
-        return request.result.hits || request.result.documents;
-      },
-      insertInRequest: null, // not eligible for search queries
-      insertInResult: (documents, request) => {
-        if (request.input.action === "search") {
-          request.result.hits = documents;
-        } else if (request.input.action === "deleteByQuery") {
-          request.result.documents = documents;
-        }
-
-        return request;
-      },
-    },
-    targets: ["search", "deleteByQuery", "export"],
-  },
-  {
-    methods: {
-      extractFromRequest: (request) => [
-        { _id: request.input.args._id, _source: request.input.body },
-      ],
-      extractFromResult: (request) => [request.result],
-      insertInRequest: (documents, request) => {
-        request.input.args._id = documents[0] && documents[0]._id;
-        request.input.body = documents[0] && documents[0]._source;
-        return request;
-      },
-      insertInResult: (documents, request) => {
-        request.setResult(documents[0], { status: request.status });
-        return request;
-      },
-    },
-    targets: ["create", "createOrReplace", "replace", "update"],
-  },
-  {
-    methods: {
-      extractFromRequest: (request) => [
-        {
-          _id: request.input.args._id,
-          _source: request.input.body.changes,
-        },
-      ],
-      extractFromResult: (request) => [request.result],
-      insertInRequest: ([document], request) => {
-        if (document) {
-          request.input.args._id = document._id;
-          request.input.body.changes = document._source;
-        }
-
-        return request;
-      },
-      insertInResult: ([document], request) => {
-        request.setResult(document, { status: request.status });
-        return request;
-      },
-    },
-    targets: ["upsert"],
-  },
-].reduce((acc, extractor) => {
-  extractor.targets.forEach((target) => {
-    acc[target] = extractor.methods;
-  });
-  return acc;
-}, {});
-
-class DocumentExtractor {
-  constructor(request) {
-    this.request = request;
-
-    const extractor = extractors[request.input.action];
-
-    if (extractor === undefined) {
-      throw kerror.get(
-        "core",
-        "fatal",
-        "assertion_failed",
-        `no generic documents extractor for ${request.input.action}`,
-      );
-    }
-
-    if (request.result) {
-      this.extractMethod = extractor.extractFromResult;
-      this.insertMethod = extractor.insertInResult;
-    } else {
-      this.extractMethod = extractor.extractFromRequest;
-      this.insertMethod = extractor.insertInRequest;
-    }
-  }
-
-  extract() {
-    return this.extractMethod(this.request);
-  }
-
-  insert(documents) {
-    return this.insertMethod(documents, this.request);
-  }
-}
-
-module.exports = DocumentExtractor;