kuzzle 2.49.1 → 2.50.0-beta.4

package/{lib → dist/lib}/util/assertType.js

@@ -18,11 +18,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const { BadRequestError } = require("../kerror/errors");
-
 /**
  * Throws if the provided data is not an object.
  * Returns the unmodified data if validated
@@ -33,17 +30,14 @@ const { BadRequestError } = require("../kerror/errors");
  * @return {object}
  */
 function assertObject(attr, data) {
-  if (data === null || data === undefined) {
-    return null;
-  }
-
-  if (typeof data !== "object" || Array.isArray(data)) {
-    throw new BadRequestError(`Attribute ${attr} must be of type "object"`);
-  }
-
-  return data;
+    if (data === null || data === undefined) {
+        return null;
+    }
+    if (typeof data !== "object" || Array.isArray(data)) {
+        throw new BadRequestError(`Attribute ${attr} must be of type "object"`);
+    }
+    return data;
 }
-
 /**
  * Throws if the provided data is not an array containing exclusively
  * values of the specified "type"
@@ -55,31 +49,23 @@ function assertObject(attr, data) {
  * @return {array}
  */
 function assertArray(attr, data, type) {
-  if (data === null || data === undefined) {
-    return [];
-  }
-
-  if (!Array.isArray(data)) {
-    throw new BadRequestError(`Attribute ${attr} must be of type "array"`);
-  }
-
-  const clone = [];
-
-  for (const d of data) {
-    if (d !== undefined && d !== null) {
-      if (typeof d !== type) {
-        throw new BadRequestError(
-          `Attribute ${attr} must contain only values of type "${type}"`,
-        );
-      }
-
-      clone.push(d);
+    if (data === null || data === undefined) {
+        return [];
+    }
+    if (!Array.isArray(data)) {
+        throw new BadRequestError(`Attribute ${attr} must be of type "array"`);
+    }
+    const clone = [];
+    for (const d of data) {
+        if (d !== undefined && d !== null) {
+            if (typeof d !== type) {
+                throw new BadRequestError(`Attribute ${attr} must contain only values of type "${type}"`);
+            }
+            clone.push(d);
+        }
     }
-  }
-
-  return clone;
+    return clone;
 }
-
 /**
  * Throws if the provided data is not a string
  * Returns the unmodified data if validated
@@ -90,17 +76,14 @@ function assertArray(attr, data, type) {
  * @return {null|string}
  */
 function assertString(attr, data) {
-  if (data === null || data === undefined) {
-    return null;
-  }
-
-  if (typeof data !== "string") {
-    throw new BadRequestError(`Attribute ${attr} must be of type "string"`);
-  }
-
-  return data;
+    if (data === null || data === undefined) {
+        return null;
+    }
+    if (typeof data !== "string") {
+        throw new BadRequestError(`Attribute ${attr} must be of type "string"`);
+    }
+    return data;
 }
-
 /**
  * Throws if the provided data is not an integer
  * Returns the unmodified data if validated
@@ -111,16 +94,15 @@ function assertString(attr, data) {
  * @return {number}
  */
 function assertInteger(attr, data) {
-  if (!Number.isInteger(data)) {
-    throw new BadRequestError(`Attribute ${attr} must be an integer`);
-  }
-
-  return data;
+    if (!Number.isInteger(data)) {
+        throw new BadRequestError(`Attribute ${attr} must be an integer`);
+    }
+    return data;
 }
-
 module.exports = {
-  assertArray,
-  assertInteger,
-  assertObject,
-  assertString,
+    assertArray,
+    assertInteger,
+    assertObject,
+    assertString,
 };
+//# sourceMappingURL=assertType.js.map

package/dist/lib/util/asyncStore.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+type Store = Map<string, unknown>;
+type RunCallback = () => void;
+interface AsyncStoreInterface {
+    run(callback: RunCallback): void;
+    exists(): boolean;
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T | undefined;
+    has(key: string): boolean;
+}
+export default class AsyncStore implements AsyncStoreInterface {
+    _asyncLocalStorage: AsyncLocalStorage<Store>;
+    constructor();
+    /**
+     * Run the provided method with an async store context
+     */
+    run(callback: RunCallback): void;
+    /**
+     * Returns true if an async store exists
+     * for the current asynchronous context
+     */
+    exists(): boolean;
+    /**
+     * Sets a value in the current async store
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Gets a value from the current async store
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Checks if a value exists in the current async store
+     */
+    has(key: string): boolean;
+    private _getStore;
+}
+export {};

package/dist/lib/util/asyncStore.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const async_hooks_1 = require("async_hooks");
+class AsyncStore {
+    constructor() {
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    /**
+     * Run the provided method with an async store context
+     */
+    run(callback) {
+        this._asyncLocalStorage.run(new Map(), callback);
+    }
+    /**
+     * Returns true if an async store exists
+     * for the current asynchronous context
+     */
+    exists() {
+        return Boolean(this._asyncLocalStorage.getStore());
+    }
+    /**
+     * Sets a value in the current async store
+     */
+    set(key, value) {
+        this._getStore().set(key, value);
+    }
+    /**
+     * Gets a value from the current async store
+     */
+    get(key) {
+        return this._getStore().get(key);
+    }
+    /**
+     * Checks if a value exists in the current async store
+     */
+    has(key) {
+        return this._getStore().has(key);
+    }
+    _getStore() {
+        const store = this._asyncLocalStorage.getStore();
+        (0, assert_1.default)(Boolean(store), "Associated AsyncStore is not set");
+        return store;
+    }
+}
+exports.default = AsyncStore;
+//# sourceMappingURL=asyncStore.js.map

package/dist/lib/util/bytes.d.ts

@@ -0,0 +1,2 @@
+export = bytes;
+declare function bytes(input: any): number;

package/dist/lib/util/bytes.js

@@ -0,0 +1,33 @@
+"use strict";
+function bytes(input) {
+    if (typeof input === "number") {
+        return input;
+    }
+    else if (typeof input !== "string") {
+        return null;
+    }
+    let unit = 1;
+    if (input.toLowerCase().includes("kb")) {
+        unit = 1024;
+    }
+    else if (input.toLowerCase().includes("mb")) {
+        unit = 1024 ** 2;
+    }
+    else if (input.toLowerCase().includes("gb")) {
+        unit = 1024 ** 3;
+    }
+    else if (input.toLowerCase().includes("tb")) {
+        unit = 1024 ** 4;
+    }
+    const match = input.match(/\d+/);
+    if (!match) {
+        return null;
+    }
+    const number = parseInt(match[0], 10);
+    if (Number.isNaN(number)) {
+        return null;
+    }
+    return number * unit;
+}
+module.exports = bytes;
+//# sourceMappingURL=bytes.js.map

package/dist/lib/util/debug.d.ts

@@ -0,0 +1,2 @@
+export = createDebug;
+declare function createDebug(namespace: any): any;

package/{lib → dist/lib}/util/debug.js

@@ -18,34 +18,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const debug = require("debug");
 const util = require("util");
-
 debug.formatters.a = (value) => {
-  const inspectOpts = debug.inspectOpts;
-
-  if (inspectOpts.expand) {
-    return `\n${util.inspect(value, inspectOpts)}`;
-  }
-
-  return util.inspect(value, inspectOpts).replace(/\s*\n\s*/g, " ");
+    const inspectOpts = debug.inspectOpts;
+    if (inspectOpts.expand) {
+        return `\n${util.inspect(value, inspectOpts)}`;
+    }
+    return util.inspect(value, inspectOpts).replace(/\s*\n\s*/g, " ");
 };
-
-debug.formatArgs = () => {};
-
+debug.formatArgs = () => { };
 function createDebug(namespace) {
-  const myDebug = debug(namespace);
-  myDebug.log = (...args) => {
-    if (!["debug", "trace"].includes(global.kuzzle.log.level)) {
-      global.kuzzle.log.level = "debug";
-    }
-    global.kuzzle.log.debug({ namespace }, ...args);
-  };
-
-  return myDebug;
+    const myDebug = debug(namespace);
+    myDebug.log = (...args) => {
+        if (!["debug", "trace"].includes(global.kuzzle.log.level)) {
+            global.kuzzle.log.level = "debug";
+        }
+        global.kuzzle.log.debug({ namespace }, ...args);
+    };
+    return myDebug;
 }
-
 module.exports = createDebug;
+//# sourceMappingURL=debug.js.map

package/dist/lib/util/deprecate.d.ts

@@ -0,0 +1 @@
+export function deprecateProperties(logger: any, target: any, deprecations?: {}): any;

package/dist/lib/util/deprecate.js

@@ -0,0 +1,64 @@
+/*
+ * 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 deprecationWarning = (logger, ...args) => {
+    if (global.NODE_ENV === "development") {
+        logger.warn("DEPRECATION WARNING");
+        logger.warn(...args);
+    }
+};
+const warnIfDeprecated = (logger, deprecations, member) => {
+    const deprecatedProperty = Object.keys(deprecations).find((deprecated) => deprecated === member), alternative = deprecations[deprecatedProperty];
+    if (!deprecatedProperty) {
+        return;
+    }
+    if (alternative && typeof alternative.message === "string") {
+        deprecationWarning(logger, alternative.message);
+    }
+    else if (typeof alternative === "string") {
+        deprecationWarning(logger, `Use of '${deprecatedProperty}' property is deprecated. Please, use '${alternative}' instead.`);
+    }
+    else {
+        deprecationWarning(logger, `Use of '${deprecatedProperty}' property is deprecated.`);
+    }
+};
+const deprecateProperties = (logger, target, deprecations = {}) => {
+    if (global.NODE_ENV !== "development") {
+        return target;
+    }
+    return new Proxy(target, {
+        get(object, key, ...rest) {
+            if (key === "__isProxy") {
+                return true;
+            }
+            warnIfDeprecated(logger, deprecations, key);
+            return Reflect.get(object, key, ...rest);
+        },
+        set(object, key, ...rest) {
+            warnIfDeprecated(logger, deprecations, key);
+            return Reflect.set(object, key, ...rest);
+        },
+    });
+};
+module.exports = {
+    deprecateProperties,
+};
+//# sourceMappingURL=deprecate.js.map

package/dist/lib/util/didYouMean.d.ts

@@ -0,0 +1,2 @@
+export = printDidYouMean;
+declare function printDidYouMean(...args: any[]): string;

package/{lib → dist/lib}/util/didYouMean.js

@@ -18,23 +18,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const didYouMean = require("didyoumean");
-
 function printDidYouMean(...args) {
-  if (global.NODE_ENV !== "development") {
-    return "";
-  }
-
-  const result = didYouMean(...args);
-
-  if (!result) {
-    return "";
-  }
-
-  return ` Did you mean "${result}"?`;
+    if (global.NODE_ENV !== "development") {
+        return "";
+    }
+    const result = didYouMean(...args);
+    if (!result) {
+        return "";
+    }
+    return ` Did you mean "${result}"?`;
 }
-
 module.exports = printDidYouMean;
+//# sourceMappingURL=didYouMean.js.map

package/dist/lib/util/extractFields.d.ts

@@ -0,0 +1,17 @@
+export = extractFields;
+/**
+ * Extract nested fields of an object in a flat array.
+ * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
+ *
+ * @param {Object} document - Document to extract fields from
+ * @param {Object} options - alsoExtractValues (false), fieldsToIgnore ( [ ] )
+ *
+ * @returns { Array<String> | Array<{ key: String, value: any }> }
+ */
+declare function extractFields(document: any, { fieldsToIgnore, alsoExtractValues }?: any, { path, extractedFields }?: {
+    path?: any;
+    extractedFields?: any[];
+}): Array<string> | Array<{
+    key: string;
+    value: any;
+}>;

package/{lib → dist/lib}/util/extractFields.js

@@ -18,11 +18,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const { isPlainObject } = require("./safeObject");
-
 /**
  * Extract nested fields of an object in a flat array.
  * Example: { field : { 1: "nested", 2: "nested" } } => [ 'field.1', 'field.2' ]
@@ -32,35 +29,24 @@ const { isPlainObject } = require("./safeObject");
  *
  * @returns { Array<String> | Array<{ key: String, value: any }> }
  */
-function extractFields(
-  document,
-  { fieldsToIgnore = [], alsoExtractValues = false } = {},
-  { path = null, extractedFields = [] } = {},
-) {
-  for (const [key, value] of Object.entries(document)) {
-    if (
-      fieldsToIgnore.length &&
-      fieldsToIgnore.find((keyToIgnore) => keyToIgnore === key)
-    ) {
-      continue;
+function extractFields(document, { fieldsToIgnore = [], alsoExtractValues = false } = {}, { path = null, extractedFields = [] } = {}) {
+    for (const [key, value] of Object.entries(document)) {
+        if (fieldsToIgnore.length &&
+            fieldsToIgnore.find((keyToIgnore) => keyToIgnore === key)) {
+            continue;
+        }
+        const currentPath = path ? `${path}.${key}` : key;
+        if (isPlainObject(value)) {
+            extractFields(value, { alsoExtractValues, fieldsToIgnore }, { extractedFields, path: currentPath });
+        }
+        else if (alsoExtractValues) {
+            extractedFields.push({ key: currentPath, value });
+        }
+        else {
+            extractedFields.push(currentPath);
+        }
     }
-
-    const currentPath = path ? `${path}.${key}` : key;
-
-    if (isPlainObject(value)) {
-      extractFields(
-        value,
-        { alsoExtractValues, fieldsToIgnore },
-        { extractedFields, path: currentPath },
-      );
-    } else if (alsoExtractValues) {
-      extractedFields.push({ key: currentPath, value });
-    } else {
-      extractedFields.push(currentPath);
-    }
-  }
-
-  return extractedFields;
+    return extractedFields;
 }
-
 module.exports = extractFields;
+//# sourceMappingURL=extractFields.js.map

package/dist/lib/util/memoize.d.ts

@@ -0,0 +1,7 @@
+export = memoize;
+declare function memoize(fn: any, resolver?: any): {
+    (...args: any[]): any;
+    fn: any;
+    cache: Map<any, any>;
+    resolver: any;
+};

package/{lib → dist/lib}/util/memoize.js

@@ -18,28 +18,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 function memoize(fn, resolver = null) {
-  const memoized = (...args) => {
-    const key = memoized.resolver !== null ? memoized.resolver(args) : args[0];
-
-    let result = memoized.cache.get(key);
-
-    if (result === undefined) {
-      result = memoized.fn(...args);
-      memoized.cache.set(key, result);
-    }
-
-    return result;
-  };
-
-  memoized.fn = fn;
-  memoized.cache = new Map();
-  memoized.resolver = resolver;
-
-  return memoized;
+    const memoized = (...args) => {
+        const key = memoized.resolver !== null ? memoized.resolver(args) : args[0];
+        let result = memoized.cache.get(key);
+        if (result === undefined) {
+            result = memoized.fn(...args);
+            memoized.cache.set(key, result);
+        }
+        return result;
+    };
+    memoized.fn = fn;
+    memoized.cache = new Map();
+    memoized.resolver = resolver;
+    return memoized;
 }
-
 module.exports = memoize;
+//# sourceMappingURL=memoize.js.map

package/dist/lib/util/promback.d.ts

@@ -0,0 +1,13 @@
+export = Promback;
+declare class Promback {
+    constructor(callback?: any);
+    _callback: any;
+    _resolve: (thenableOrResult?: any) => void;
+    _reject: (error?: any) => void;
+    deferred: Bluebird<any>;
+    isPromise: boolean;
+    resolve(result: any): Bluebird<any>;
+    reject(error: any): Bluebird<any>;
+    get promise(): Bluebird<any>;
+}
+import Bluebird = require("bluebird");

package/dist/lib/util/promback.js

@@ -0,0 +1,60 @@
+/*
+ * 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");
+class Promback {
+    constructor(callback = null) {
+        this._callback = callback;
+        this._resolve = null;
+        this._reject = null;
+        this.deferred = null;
+        this.isPromise = this._callback === null;
+        if (this.isPromise) {
+            this.deferred = new Bluebird((res, rej) => {
+                this._resolve = res;
+                this._reject = rej;
+            });
+        }
+    }
+    resolve(result) {
+        if (this.isPromise) {
+            this._resolve(result);
+        }
+        else {
+            this._callback(null, result);
+        }
+        return this.deferred;
+    }
+    reject(error) {
+        if (this.isPromise) {
+            this._reject(error);
+        }
+        else {
+            this._callback(error);
+        }
+        return this.deferred;
+    }
+    get promise() {
+        return this.deferred;
+    }
+}
+module.exports = Promback;
+//# sourceMappingURL=promback.js.map

package/dist/lib/util/requestAssertions.d.ts

@@ -0,0 +1,10 @@
+export function assertArgsHasAttribute(request: Request, attribute: any): void;
+export function assertBodyAttributeType(request: Request, attribute: string, type: any): boolean;
+export function assertBodyHasAttribute(request: Request, attribute: string): void;
+export function assertBodyHasNotAttribute(request: Request, attribute: string): void;
+export function assertHasBody(request: Request): void;
+export function assertHasId(request: Request): void;
+export function assertHasIndex(request: Request): void;
+export function assertHasIndexAndCollection(request: Request): void;
+export function assertIsAuthenticated(anonymousId: any, request: Request): void;
+export function assertIsObject(value: any): void;