DOCSEARCHbyAlgolia
Submit Docs

Kuzzle Documentation

website·Indexed 35 days ago

https://docs.kuzzle.io/

Documentation for Kuzzle, including API v1.x and v2.x, core guides v2.x, and official plugins such as Device Manager and Workflows. Includes SDK references for JavaScript (v5.x, v6.x), Java (v2.x, v3.x), PHP (v3.x), Android (v3.x), and C++ (v1.x).

Tokens
1.2M
Snippets
6.9K
Records
9.4K
Agent score
62%

What's inside Kuzzle

  1. Overview of the Koncorde real-time data percolation engine

    Koncorde is the engine used by Kuzzle to handle real-time notifications and data validations. It functions as a real-time data percolation engine that allows for the creation of fine-grained filters, including geofencing capabilities, by utilizing a specific set of clauses and operators.

  2. Overview of Kuzzle Plugin types

    Kuzzle allows extending its functionality through Plugins and Protocols. Plugins share Kuzzle's execution thread and can implement one or more of the following interfaces:

    • Hooks: Asynchronous listeners triggered by data events. Kuzzle does not wait for hooks to complete before continuing its process.
    • Pipes: Synchronous listeners triggered by data events. Kuzzle waits for the pipe to return data; if a pipe returns an error, the Kuzzle lifecycle is interrupted.
    • Controllers: Used to extend the Kuzzle API with new endpoints.
    • Strategies: Used to add authentication strategies to identify and authenticate users.

    Protocols are used to add extended networking capabilities or handle proprietary transport protocols.

  3. Overview of Koncorde data percolation engine

    Koncorde is a data percolation engine used within Kuzzle to trigger notifications on real-time subscriptions and perform data validation. Unlike a search engine that indexes data to match filters, a percolation engine indexes filters and matches them against incoming data streams. Key properties include: the ability to index an arbitrary number of filters, returning matching filters whenever data is submitted, and the fact that data is never stored within the engine. Its DSL is inspired by Elasticsearch and supports complex filtering, including geo-localized data (e.g., bounding polygons).

  5. Overview of Kuzzle Authentication Architecture

    Kuzzle utilizes Passport.js to provide a flexible authentication system supporting multiple strategies (e.g., OAuth2, SAML, and Local). The process involves several core components: the Auth Controller (manages the process), the Passport Wrapper (interfaces Kuzzle with Passport.js), User and Token Repositories (store user data), and Auth Strategies (dedicated plugins that validate credentials).

  6. Overview of Kuzzle Generic Document Events

    Generic Document Events allow you to apply modifications homogeneously to documents processed by the document controller. They are triggered before and after documents are processed.

    Key behaviors:

    • generic:document:before* events trigger before regular document:before* events.
    • generic:document:after* events trigger after regular document:after* events.
    • All generic events share the same payload signature: they receive an array of documents and a request object, and must resolve to the updated (or original) array of documents.
    • Constraint: "before" actions are only triggered on queries for specific documents. Bulk or query-based actions like document:search, document:deleteByQuery, or document:updateByQuery only trigger "after" events.
    • Special Event: generic:document:injectMetadata is called specifically before _kuzzle_info metadata is injected into a document.

  7. Overview of Kuzzle IoT Dashboard Builder widgets

    The Dashboard Builder allows for the creation of personalized dashboards to visualize Kuzzle IoT platform data. It provides three default widget types:

    • Chart: Visualizes data sources as graphs.
    • Map: Displays assets, devices, or position history on a map.
    • Table: Displays information in a spreadsheet-style table.

  8. Overview of Kuzzle Realtime Engine

    Kuzzle provides a high-performance Realtime Engine for sending notifications to clients. To use realtime capabilities, a persistent communication protocol such as WebSocket or MQTT must be used. The engine supports two primary modes: Volatile Pub/Sub and Realtime Database Notifications.

  10. Overview of the Kuzzle Cloudinary Plugin

    The Kuzzle Cloudinary plugin integrates Cloudinary's cloud-based image and video management platform into Kuzzle. It allows developers to utilize Cloudinary's API functions within Kuzzle to automate image-processing pipelines, including uploads, on-the-fly manipulations, optimization, and dynamic delivery via CDN.

  11. Overview of the Audit Trail module

    The Audit Trail module records significant user actions on the platform, capturing who performed the action, when it occurred, and whether it succeeded. It is implemented as the AuditTrailPlugin and operates as a top-level plugin alongside the PlatformConfigPlugin.

  12. Overview of Kuzzle Generic Document Events

    Generic Document Events (available since 1.9.0) allow you to apply modifications to documents during the request or result phase of document controller actions.

    • Before events (generic:document:before*) trigger before the regular document:before* event.
    • After events (generic:document:after*) trigger after the regular document:after* event.

    All pipes triggered by these events must resolve the array of updated documents.

    class PipePlugin {
  init(customConfig, context) {
    this.pipes = {
      'generic:document:<event>': async (documents, request) => {
        // modify documents
        return documents;
      }
    };
  }
}