Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

X Engine

The X Engine is the core system that powers Kinesis API's visual API development capabilities. It allows developers to design, implement, and deploy complex API routes using a block-based visual system, dramatically reducing the learning curve and development time typically associated with API creation.

Overview

At its essence, the X Engine is an execution framework that transforms visual blocks into functional API endpoints. By abstracting away much of the underlying complexity, it enables developers to focus on business logic rather than implementation details. The X Engine's modular architecture makes it both powerful for experienced developers and accessible to those with less backend expertise.

Core Components

The X Engine consists of four primary component types that work together to handle API requests:

Processors

Processors control the execution flow of your API logic:

  • Function: Handle the flow of execution within an API route
  • Examples:
    • Loop: Iterate through collections of data
    • If/Else: Implement conditional logic
    • Try/Catch: Handle errors gracefully
    • Return: Send a response back to the client
    • Break: Exit from a loop
    • Fail: Trigger an error state with a specific message

Processors are the backbone of API route logic, allowing you to implement complex algorithms and workflows through visual components.

Resolvers

Resolvers map requests to the appropriate data sources:

  • Function: Retrieve and manipulate data from various sources
  • Examples:
    • Table: Query the Kinesis DB for records
    • Request: Extract data from the incoming API request
    • Auth: Access authentication information
    • State: Manage state between route executions
    • Config: Retrieve configuration values
    • External: Connect to external APIs or services

Resolvers serve as the bridge between your API endpoints and the data they need to operate, whether from internal or external sources.

Convertors

Convertors transform data between different formats:

  • Function: Transform and validate data during processing
  • Examples:
    • String: Manipulate text data
    • Number: Perform mathematical operations
    • Boolean: Evaluate logical conditions
    • Array: Work with collections of items
    • Object: Manipulate structured data
    • JSON: Parse and stringify JSON data
    • Date: Handle date and time operations

Convertors ensure that data is in the correct format at each stage of processing, reducing errors and simplifying data manipulation.

Definitions

Definitions specify the expected structure of data:

  • Function: Define the expected result format for each block
  • Examples:
    • Schema: Define the structure of data objects
    • Response: Specify the format of API responses
    • Request: Describe expected request formats
    • Error: Define standardized error structures

Definitions act as contracts between different parts of your API, ensuring consistency and making your API more predictable and easier to use.

How It Works

The X Engine processes API requests through the following stages:

  1. Request Reception: When an API endpoint receives a request, the X Engine initializes the execution context.

  2. Block Execution: The engine processes each block in sequence according to the route's configuration, with processors controlling the flow.

  3. Data Retrieval: Resolvers fetch necessary data from appropriate sources.

  4. Data Transformation: Convertors format and transform data as needed.

  5. Validation: The engine validates data against definitions at various stages.

  6. Response Generation: Finally, a response is constructed and returned to the client.

This entire process is visually designed through the Kinesis API interface, allowing you to create sophisticated API logic without writing traditional code.

Block Connections

Blocks in the X Engine are connected through a visual interface that represents the flow of data and execution:

  • Inputs: Each block can accept inputs from other blocks or direct values
  • Outputs: Blocks produce outputs that can be used by subsequent blocks
  • Conditions: Control blocks (like If/Else) can have multiple output paths
  • Variables: Named references allow data to flow between different parts of your route

The visual representation makes it easy to understand complex flows and troubleshoot issues.

Visual Editor

The X Engine is integrated with a visual editor in the Kinesis API web interface, providing:

  • Drag-and-drop Interface: Easily add and arrange blocks
  • Real-time Validation: Immediate feedback on configuration issues
  • Testing Tools: Test your routes directly from the editor
  • Version History: Track changes to your routes over time
  • Visual Debugging: Follow execution flow with visual indicators

The editor makes creating complex API routes accessible to developers of all skill levels.

Advanced Features

The X Engine includes several advanced features, some of which are still in active development, for complex API development:

Authentication Integration

The X Engine seamlessly integrates with Kinesis API's authentication system:

  • Role-based Access: Control which users can access specific routes
  • JWT Validation: Automatically validate authentication tokens
  • Permission Checking: Enforce granular permissions within routes

Custom Functions

Extend the X Engine with custom functions:

  • Reusable Logic: Create custom blocks for frequently used operations
  • Library Integration: Wrap third-party libraries in custom blocks
  • Complex Algorithms: Implement specialized business logic as reusable components

Middleware Support

Apply consistent processing across multiple routes:

  • Pre-processing: Validate requests before main processing
  • Post-processing: Format responses consistently
  • Error Handling: Implement global error management

Versioning

Manage API changes over time:

  • Route Versioning: Maintain multiple versions of the same endpoint
  • Migration Paths: Provide smooth transitions between versions
  • Deprecation Management: Gracefully phase out older endpoints

Best Practices

Performance Optimization

  • Minimize database queries by combining resolvers where possible
  • Use caching for frequently accessed data
  • Process only the data you need using selective field retrieval

Security Considerations

  • Always validate user input through definitions
  • Implement proper authentication and authorization
  • Use parametrized queries to prevent injection attacks
  • Avoid exposing sensitive data in responses

Maintainability

  • Name blocks clearly to document their purpose
  • Group related functionality into logical sections
  • Comment complex logic for future reference
  • Use consistent patterns across similar routes

Testing

  • Test edge cases and error conditions
  • Validate response formats against your definitions
  • Check performance under various load conditions
  • Test with realistic data volumes
  • API Reference - Complete reference for all available API endpoints
  • Routes - How to create and manage API routes in Kinesis API
  • Playground - Interactive environment for testing your APIs

Conclusion

The X Engine represents a paradigm shift in API development, combining the power and flexibility of traditional programming with the accessibility and speed of visual development. By abstracting complex implementation details while maintaining full capability, it enables developers of all skill levels to create professional-grade APIs in a fraction of the time typically required.

Whether you're prototyping a simple API or building complex, interconnected systems, the X Engine provides the tools to accelerate development without sacrificing quality or control.