kuzzle 2.49.1 → 2.50.0-beta.3

package/dist/lib/api/controllers/realtimeController.d.ts

@@ -0,0 +1,47 @@
+export = RealtimeController;
+/**
+ * @class RealtimeController
+ */
+declare class RealtimeController extends NativeController {
+    constructor();
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    subscribe(request: Request): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    join(request: Request): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<String>}
+     */
+    unsubscribe(request: Request): Promise<string>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    count(request: Request): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    list(request: Request): Promise<any>;
+    /**
+     * Publish a realtime message
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    publish(request: Request): Promise<any>;
+    /**
+     * Validate a document against collection validation specifications.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    validate(request: Request): Promise<any>;
+}
+import { NativeController } from "./baseController";

package/dist/lib/api/controllers/realtimeController.js

@@ -0,0 +1,128 @@
+/*
+ * 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");
+/**
+ * @class RealtimeController
+ */
+class RealtimeController extends NativeController {
+    constructor() {
+        super([
+            "count",
+            "join",
+            "list",
+            "publish",
+            "subscribe",
+            "unsubscribe",
+            "validate",
+        ]);
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    async subscribe(request) {
+        // assertion checks
+        request.getIndexAndCollection();
+        request.getBody();
+        // Only funnel protocol (and thus the embedded SDK) can use "propagate"
+        // option
+        if (request.context.connection.protocol !== "funnel" ||
+            request.input.args.propagate === undefined ||
+            request.input.args.propagate === null) {
+            request.input.args.propagate = true;
+        }
+        else {
+            request.input.args.propagate = request.getBoolean("propagate");
+        }
+        const result = await global.kuzzle.ask("core:realtime:subscribe", request);
+        if (!result) {
+            // can occur if the connection is dead.
+            // If so, we don't really have to care about the response
+            return null;
+        }
+        return result;
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    async join(request) {
+        // assertion checks
+        request.getBodyString("roomId");
+        return global.kuzzle.ask("core:realtime:join", request);
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise<String>}
+     */
+    async unsubscribe(request) {
+        const roomId = request.getBodyString("roomId");
+        await global.kuzzle.ask("core:realtime:unsubscribe", request.context.connection.id, roomId);
+        return { roomId };
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    async count(request) {
+        const roomId = request.getBodyString("roomId");
+        return {
+            count: await global.kuzzle.ask("cluster:realtime:room:count", roomId),
+        };
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    list(request) {
+        return global.kuzzle.ask("core:realtime:list", request.context.user);
+    }
+    /**
+     * Publish a realtime message
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    async publish(request) {
+        // assertion checks
+        request.getBody();
+        request.getIndexAndCollection();
+        const newRequest = await global.kuzzle.validation.validate(request, false);
+        newRequest.input.body._kuzzle_info = {
+            author: request.getKuid(),
+            createdAt: Date.now(),
+        };
+        await global.kuzzle.ask("core:realtime:publish", newRequest);
+        return { published: true };
+    }
+    /**
+     * Validate a document against collection validation specifications.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    validate(request) {
+        return global.kuzzle.funnel.controllers.get("document").validate(request);
+    }
+}
+module.exports = RealtimeController;
+//# sourceMappingURL=realtimeController.js.map

package/dist/lib/api/controllers/securityController.d.ts

@@ -0,0 +1,423 @@
+import { KuzzleRequest } from "../request";
+import { NativeController } from "./baseController";
+/**
+ * @class SecurityController
+ */
+export default class SecurityController extends NativeController {
+    protected readonly subdomain: string;
+    protected readonly securityCollections: string[];
+    protected getStrategyMethod: any;
+    protected readonly logger: any;
+    protected anonymousId: string | null;
+    static userOrSdk(userId: string | null): string;
+    constructor();
+    /**
+     * Checks if an API action can be executed by a user
+     */
+    checkRights(request: KuzzleRequest): Promise<{
+        allowed: any;
+    }>;
+    /**
+     * Creates a new API key for a user
+     */
+    createApiKey(request: KuzzleRequest): Promise<any>;
+    /**
+     * Search in an user API keys
+     */
+    searchApiKeys(request: KuzzleRequest): Promise<{
+        hits: any[];
+        total: number;
+    }>;
+    /**
+     * Deletes an user API key
+     */
+    deleteApiKey(request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Get the role mapping
+     *
+     * @returns {Promise}
+     */
+    getRoleMapping(): Promise<{
+        mapping: any;
+    }>;
+    /**
+     * Update the roles collection mapping
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    updateRoleMapping(request: KuzzleRequest): Promise<any>;
+    /**
+     * Get the profile mapping
+     *
+     * @returns {Promise}
+     */
+    getProfileMapping(): Promise<{
+        mapping: any;
+    }>;
+    /**
+     * Update the profiles collection mapping
+  
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    updateProfileMapping(request: any): Promise<any>;
+    /**
+     * Get the user mapping
+     *
+     * @returns {Promise}
+     */
+    getUserMapping(): Promise<{
+        mapping: any;
+    }>;
+    /**
+     * Update the users collection mapping
+  
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    updateUserMapping(request: KuzzleRequest): Promise<any>;
+    /**
+     * Get a specific role according to the given id
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getRole(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/role").Role>>;
+    /**
+     * Get specific roles according to given ids
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    mGetRoles(request: KuzzleRequest): Promise<{
+        hits: any;
+    }>;
+    /**
+     * Refresh a security collection (users, roles, profiles)
+     *
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    refresh(request: KuzzleRequest): Promise<any>;
+    /**
+     * Search for roles
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    searchRoles(request: KuzzleRequest): Promise<any>;
+    /**
+     * Create or replace a Role
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createOrReplaceRole(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/role").Role>>;
+    /**
+     * Create a Role
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createRole(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/role").Role>>;
+    /**
+     * Remove a role according to the given id
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    deleteRole(request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Get a specific profile according to the given id
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getProfile(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/profile").Profile>>;
+    /**
+     * Get specific profiles according to given ids
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    mGetProfiles(request: KuzzleRequest): Promise<{
+        hits: any;
+    }>;
+    /**
+     * Create or replace a Profile
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createOrReplaceProfile(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/profile").Profile>>;
+    /**
+     * Create a Profile
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createProfile(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/profile").Profile>>;
+    /**
+     * Deletes a profile
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    deleteProfile(request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Search for profiles
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    searchProfiles(request: KuzzleRequest): Promise<any>;
+    /**
+     * Given a user id, returns the matching User object
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Get specific users according to given ids
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    mGetUsers(request: KuzzleRequest): Promise<{
+        hits: any;
+    }>;
+    /**
+     * Given a profile id, returns the matching profile's rights as an array.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getProfileRights(request: KuzzleRequest): Promise<{
+        hits: any[];
+        total: number;
+    }>;
+    /**
+     * Given a user id, returns the matching user's rights as an array.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getUserRights(request: KuzzleRequest): Promise<{
+        hits: any[];
+        total: number;
+    }>;
+    /**
+     * Given a user id, returns the matching user's strategies as an array.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getUserStrategies(request: KuzzleRequest): Promise<{
+        strategies: any[];
+        total: number;
+    }>;
+    /**
+     * Returns the User objects matching the given query
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    searchUsers(request: KuzzleRequest): Promise<{
+        hits: any;
+        scrollId: any;
+        total: any;
+    }>;
+    /**
+     * Given a credentials related search query, returns matched users' kuid.
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    searchUsersByCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * Deletes a user from Kuzzle
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    deleteUser(request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Creates a new User object in Kuzzle's database layer
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Creates a new User object in Kuzzle's database layer and applies restricted profileIds
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createRestrictedUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Updates an existing User
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    updateUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Applies a partial update to an existing user.
+     * If the user doesn't already exist, a new user is created.
+     *
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    upsertUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Replaces an existing User
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    replaceUser(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Updates an existing profile
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    updateProfile(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/profile").Profile>>;
+    /**
+     * Updates an existing role
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    updateRole(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/role").Role>>;
+    /**
+     * Creates the first admin user if it does not already exist
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createFirstAdmin(request: KuzzleRequest): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Deletes multiple profiles
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    mDeleteProfiles(request: any): Promise<any[]>;
+    /**
+     * Deletes multiple roles
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    mDeleteRoles(request: any): Promise<any[]>;
+    /**
+     * Deletes multiple users
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    mDeleteUsers(request: any): Promise<any[]>;
+    /**
+     * Scroll a paginated users search result
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    scrollUsers(request: KuzzleRequest): Promise<any>;
+    /**
+     * Scroll a paginated profiles search result
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    scrollProfiles(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    createCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    updateCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    hasCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    validateCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    deleteCredentials(request: KuzzleRequest): Promise<{
+        acknowledged: boolean;
+    }>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getCredentials(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getCredentialsById(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    getCredentialFields(request: KuzzleRequest): Promise<string[]>;
+    /**
+     * @returns {Promise<Object>}
+     */
+    getAllCredentialFields(): Promise<{}>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<null>}
+     */
+    revokeTokens(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {string.<profile|role|user>} type
+     * @param {Request} request
+     * @returns {Promise.<Array.<string>>}
+     * @private
+     */
+    _mDelete(type: string, request: KuzzleRequest): Promise<any[]>;
+    /**
+     * @returns {Promise}
+     * @private
+     */
+    _changeUser(request: KuzzleRequest, id: string, content: any, userId: string | null, profileIds: string[] | null): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * @param {Request} request
+     * @returns {Promise}
+     * @private
+     */
+    _persistUser(request: KuzzleRequest, profileIds: string[], content: any, { humanReadableId }?: {
+        humanReadableId?: boolean;
+    }): Promise<import("../../types/core/auth/formatProcessing.type").Serialized<import("../../model/security/user").User>>;
+    /**
+     * Checks if a search result can exceeds the server configured limit
+     * @param {Request} request
+     * @param {number} limit
+     * @throws
+     */
+    _getSearchPageSize(request: KuzzleRequest): number;
+}