kuzzle 2.49.1 → 2.50.0-beta.4

package/bin/start-kuzzle-server

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-
-/*
- * 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";
-
-/* eslint-disable no-console */
-
-const fs = require("fs");
-
-const yargs = require("yargs");
-
-const { Backend } = require("../index");
-
-function loadJson(path) {
-  if (!path) {
-    return {};
-  }
-
-  return JSON.parse(fs.readFileSync(path, "utf8"));
-}
-
-async function startKuzzle(options = {}) {
-  const app = new Backend("kuzzle");
-
-  if (options.enablePlugins) {
-    const additionalPlugins = options.enablePlugins
-      .trim()
-      .split(",")
-      .map((x) => x.trim().replace(/(^")|("$)/g, ""));
-
-    for (const additionalPlugin of additionalPlugins) {
-      const PluginClass = require(`../plugins/available/${additionalPlugin}`);
-      const manifest = require(
-        `../plugins/available/${additionalPlugin}/manifest.json`,
-      );
-      const plugin = new PluginClass();
-
-      try {
-        plugin.version = require(
-          `../plugins/available/${additionalPlugin}/package.json`,
-        ).version;
-      } catch (e) {
-        // ignore
-      }
-
-      app.plugin.use(plugin, { manifest, name: manifest.name });
-    }
-  }
-
-  app._support.mappings = loadJson(options.mappings);
-
-  app._support.fixtures = loadJson(options.fixtures);
-
-  app._support.securities = loadJson(options.securities);
-
-  app.vault.key = options.vaultKey;
-
-  app.vault.file = options.secretsFile;
-
-  app.version = "1.0.0";
-
-  await app.start();
-
-  const { total: admins } = await app.sdk.security.searchUsers({
-    query: { term: { profileIds: "admin" } },
-  });
-
-  if (admins.length === 0) {
-    console.log(
-      "[!] [WARNING] There is no administrator user yet: everyone has administrator rights.",
-    );
-    console.log(
-      "[ℹ]  You can use the CLI or the admin console to create the first administrator user.",
-    );
-    console.log(
-      "    For more information: https://docs.kuzzle.io/core/2/guides/essentials/security/",
-    );
-  }
-}
-
-const options = yargs()
-  .scriptName("kuzzle")
-  .usage("start-kuzzle-server [options]")
-  .describe("fixtures", "Import data from file")
-  .describe("mappings", "Apply mappings from file")
-  .describe("securities", "Import roles, profiles and users from file")
-  .describe("vault-key", "Vault key used to decrypt secrets")
-  .describe("secrets-file", "Output file to write decrypted secrets")
-  .describe(
-    "enable-plugins",
-    'Enable plugins from "plugins/available" directory',
-  ).argv;
-
-const run = async () => {
-  try {
-    await startKuzzle(options);
-  } catch (error) {
-    console.error(`[x] [ERROR] ${error.stack}`);
-    process.exit(1);
-  }
-};
-
-run();
-
-// Used for tests only
-module.exports = startKuzzle;

package/check-node-version.js

@@ -1,17 +0,0 @@
-/* eslint-disable no-console */
-
-"use strict";
-
-const semver = require("semver");
-const { engines } = require("./package.json");
-
-const version = engines.node;
-const nodeVersion = process.version;
-
-if (!semver.satisfies(nodeVersion, version)) {
-  console.error(
-    "\x1b[31m%s\x1b[0m",
-    `Required node version ${version} not satisfied with current version ${nodeVersion}`,
-  );
-  process.exit(1);
-}

package/lib/api/controllers/adminController.js

@@ -1,229 +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 Bluebird = require("bluebird");
-
-const kerror = require("../../kerror");
-const { NativeController } = require("./baseController");
-const { Mutex } = require("../../util/mutex");
-
-/**
- * @class AdminController
- */
-class AdminController extends NativeController {
-  constructor() {
-    super([
-      "dump",
-      "loadFixtures",
-      "loadMappings",
-      "loadSecurities",
-      "refreshIndexCache",
-      "resetCache",
-      "resetDatabase",
-      "resetSecurity",
-      "shutdown",
-    ]);
-
-    this.shuttingDown = false;
-    this.logger = global.kuzzle.log.child("api:controllers:admin");
-  }
-
-  async refreshIndexCache() {
-    await global.kuzzle.ask("core:storage:public:cache:refresh");
-  }
-
-  /**
-   * Reset Redis cache
-   */
-  async resetCache(request) {
-    const database = request.getString("database");
-
-    // @todo allow only memoryStorage
-    if (database === "internalCache") {
-      await this.ask("core:cache:internal:flushdb");
-    } else if (database === "memoryStorage") {
-      await this.ask("core:cache:public:flushdb");
-    } else {
-      throw kerror.get("services", "cache", "database_not_found", database);
-    }
-
-    return { acknowledge: true };
-  }
-
-  /**
-   * Reset all roles, profiles and users
-   */
-  async resetSecurity() {
-    const mutex = new Mutex("resetSecurity", { timeout: 0 });
-
-    if (!(await mutex.lock())) {
-      throw kerror.get(
-        "api",
-        "process",
-        "action_locked",
-        "Kuzzle is already reseting roles, profiles and users.",
-      );
-    }
-
-    const result = {};
-
-    try {
-      const options = { refresh: "wait_for" };
-
-      result.deletedUsers = await this.ask(
-        "core:security:user:truncate",
-        options,
-      );
-      result.deletedProfiles = await this.ask(
-        "core:security:profile:truncate",
-        options,
-      );
-      result.deletedRoles = await this.ask(
-        "core:security:role:truncate",
-        options,
-      );
-
-      await global.kuzzle.internalIndex.createInitialSecurities();
-
-      await this.ask(
-        "core:cache:internal:del",
-        `backend:init:import:permissions`,
-      );
-    } finally {
-      await mutex.unlock();
-    }
-
-    return result;
-  }
-
-  /**
-   * Reset all indexes created by users
-   */
-  async resetDatabase() {
-    const mutex = new Mutex("resetDatabase", { timeout: 0 });
-
-    if (!(await mutex.lock())) {
-      throw kerror.get(
-        "api",
-        "process",
-        "action_locked",
-        "Kuzzle is already reseting all indexes.",
-      );
-    }
-
-    try {
-      const indexes = await this.ask("core:storage:public:index:list");
-      await this.ask("core:storage:public:index:mDelete", indexes);
-
-      await this.ask("core:cache:internal:del", `backend:init:import:mappings`);
-
-      return { acknowledge: true };
-    } finally {
-      await mutex.unlock();
-    }
-  }
-
-  /**
-   * Generate a dump
-   * Kuzzle will throw a PreconditionError if a dump is already running
-   */
-  dump(request) {
-    const waitForRefresh = request.input.args.refresh === "wait_for";
-    const suffix = request.getString("suffix", "manual-api-action");
-
-    const promise = global.kuzzle.dump(suffix);
-
-    return this._waitForAction(waitForRefresh, promise);
-  }
-
-  /**
-   * Shutdown Kuzzle
-   */
-  async shutdown() {
-    if (this.shuttingDown) {
-      throw kerror.get(
-        "api",
-        "process",
-        "action_locked",
-        "Kuzzle is already shutting down.",
-      );
-    }
-
-    global.kuzzle.shutdown();
-
-    return { acknowledge: true };
-  }
-
-  loadFixtures(request) {
-    const fixtures = request.getBody();
-    const refresh = request.getRefresh("wait_for");
-
-    return global.kuzzle.ask("core:storage:public:document:import", fixtures, {
-      refresh,
-    });
-  }
-
-  loadMappings(request) {
-    const mappings = request.getBody();
-
-    return this._waitForAction(
-      request.getRefresh("wait_for"),
-      global.kuzzle.ask("core:storage:public:mappings:import", mappings, {
-        rawMappings: true,
-      }),
-    );
-  }
-
-  async loadSecurities(request) {
-    const permissions = request.getBody();
-    const user = request.getUser();
-    const onExistingUsers = request.input.args.onExistingUsers;
-    const force = request.getBoolean("force");
-    const waitForRefresh = request.getRefresh("wait_for");
-
-    const promise = this.ask("core:security:load", permissions, {
-      force,
-      onExistingUsers,
-      refresh: waitForRefresh,
-      user,
-    });
-
-    return this._waitForAction(waitForRefresh, promise);
-  }
-
-  _waitForAction(waitForRefresh, promise) {
-    const result = { acknowledge: true };
-
-    if (waitForRefresh === "false") {
-      // Attaching an error handler to the provided promise to prevent
-      // uncaught rejections
-      promise.catch((err) => this.logger.error(err));
-
-      return Bluebird.resolve(result);
-    }
-
-    return promise.then(() => result);
-  }
-}
-
-module.exports = AdminController;

package/lib/api/controllers/bulkController.js

@@ -1,210 +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 { NativeController } = require("./baseController");
-const actionEnum = require("../../core/realtime/actionEnum");
-const kerror = require("../../kerror");
-
-/**
- * @class BulkController
- */
-class BulkController extends NativeController {
-  constructor() {
-    super(["import", "write", "mWrite", "deleteByQuery", "updateByQuery"]);
-  }
-
-  /**
-   * Perform a bulk import
-   *
-   * @param {Request} request
-   * @returns {Promise}
-   */
-  async import(request) {
-    const userId = request.getKuid();
-    const { index, collection } = request.getIndexAndCollection();
-    const strict = request.getBoolean("strict");
-    const refresh = request.getRefresh();
-    const bulkData = request.getBodyArray("bulkData");
-    const options = {
-      refresh,
-      userId,
-    };
-
-    const { items, errors } = await this.ask(
-      "core:storage:public:document:bulk",
-      index,
-      collection,
-      bulkData,
-      options,
-    );
-
-    if (strict && errors.length) {
-      throw kerror.get(
-        "api",
-        "process",
-        "incomplete_multiple_request",
-        "import",
-        errors,
-      );
-    }
-
-    // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
-
-    return {
-      errors,
-      successes: items,
-    };
-  }
-
-  /**
-   * Write a document without adding metadata or performing data validation.
-   */
-  async write(request) {
-    const { index, collection } = request.getIndexAndCollection();
-    const id = request.getId({ ifMissing: "ignore" });
-    const content = request.getBody();
-    const refresh = request.getRefresh();
-    const notify = request.getBoolean("notify");
-
-    const result = await this.ask(
-      "core:storage:public:document:createOrReplace",
-      index,
-      collection,
-      id,
-      content,
-      { injectKuzzleMeta: false, refresh },
-    );
-
-    if (notify) {
-      await this.ask(
-        "core:realtime:document:notify",
-        request,
-        actionEnum.WRITE,
-        result,
-      );
-    }
-
-    return {
-      _id: result._id,
-      _source: result._source,
-      _version: result._version,
-    };
-  }
-
-  /**
-   * Write several documents without adding metadata or performing data validation.
-   */
-  async mWrite(request) {
-    const { index, collection } = request.getIndexAndCollection();
-    const documents = request.getBodyArray("documents");
-    const strict = request.getBoolean("strict");
-    const refresh = request.getRefresh();
-    const notify = request.getBoolean("notify");
-
-    const { items, errors } = await this.ask(
-      "core:storage:public:document:mCreateOrReplace",
-      index,
-      collection,
-      documents,
-      { injectKuzzleMeta: false, limits: false, refresh },
-    );
-
-    if (strict && errors.length) {
-      throw kerror.get(
-        "api",
-        "process",
-        "incomplete_multiple_request",
-        "write",
-        errors,
-      );
-    }
-
-    // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
-
-    if (notify) {
-      await global.kuzzle.ask(
-        "core:realtime:document:mNotify",
-        request,
-        actionEnum.WRITE,
-        items,
-      );
-    }
-
-    const successes = items.map((item) => ({
-      _id: item._id,
-      _source: item._source,
-      _version: item._version,
-    }));
-
-    return {
-      errors,
-      successes,
-    };
-  }
-
-  /**
-   * Directly deletes every documents matching the search query without:
-   *  - applying max documents write limit
-   *  - fetching deleted documents
-   *  - triggering realtime notifications
-   */
-  async deleteByQuery(request) {
-    const { index, collection } = request.getIndexAndCollection();
-    const query = request.getBodyObject("query");
-    const refresh = request.getRefresh();
-
-    const { deleted } = await this.ask(
-      "core:storage:public:document:deleteByQuery",
-      index,
-      collection,
-      query,
-      { fetch: false, refresh, size: -1 },
-    );
-
-    return { deleted };
-  }
-
-  /**
-   * Directly update every document matching the search query without:
-   *  - Applying max documents write limit
-   *  - Injecting Kuzzle metadata
-   *  - Triggering realtime notifications
-   */
-  async updateByQuery(request) {
-    const { index, collection } = request.getIndexAndCollection();
-    const query = request.getBodyObject("query");
-    const changes = request.getBodyObject("changes");
-    const refresh = request.getRefresh();
-
-    return this.ask(
-      "core:storage:public:bulk:updateByQuery",
-      index,
-      collection,
-      query,
-      changes,
-      { refresh },
-    );
-  }
-}
-
-module.exports = BulkController;