Building With Visual Development

The Function Stack

The Function Stack in Swiftybase is your main tool for visually developing business logic. It provides a user-friendly interface to design and manage the logic required for your application.

Anatomy of the Visual Builder

The visual builder consists of up to three sections: inputs, the function stack, and the response. Depending on the type of function stack you’re working with, some sections may not be available. These sections work together to help you design and manage your backend operations.

Sections Overview:

• Inputs: Where you define and manage incoming data to be processed.

Here id input is defined in the path variable passed to the route /order/:id. The type is explicitly specified as an integer.

• Function Stack: The core logic that processes the inputs and manipulates data.

In this example, we execute a MySQL query to retrieve a specific order by its id. On the left panel, you can see that we passed the input orderId and defined a custom model for the returned result. Unlike other no-code builders, everything in Swiftybase is fully typed, making the process much easier.

• Response: Defines what data is returned once the function stack completes its task.

Finally, we return the result as a JSON object with the key order, representing the order details.

This modular approach allows you to build complex workflows and business logic quickly and efficiently.

What Can I Build?

APIs

An API is a set of logic or workflows that can be triggered from external sources. Whenever you tap a button or click a link in an application, API calls are happening in the background to execute the intended actions.

Custom Functions

A custom function works similarly to an API but is designed for reuse within other function stacks. It helps you avoid duplicating logic across multiple places, making it easier to manage and maintain your workflows efficiently.

Swiftybase Types in Function Stack

Swiftybase provides a fully typed system for defining structured inputs in your function stack. You can declare structured data types that are automatically unmarshaled from JSON when received and marshaled back to JSON when returned. This ensures type safety and improves the reliability of your APIs.

Defining Structs for Inputs

In Swiftybase, you can define structured inputs as structs, allowing you to organize related data efficiently. These structures support all primitive types, including:

• Integer types: int, int8, int16, int32, int64
• Unsigned integers: uint, uint8, uint16, uint32, uint64
• Floating-point numbers: float32, float64
• Boolean: bool
• Strings: string
• List: with specified value type like List<String>
• Map: with specified key and value type like Map<String, Any>
• Nullable types: Any type can be marked as nullable`

Example

{
  "userData": {
    "id": 123,
    "name": "Alice",
    "age": 25,
    "isActive": true
  }
}

You can define a User model with your desiered fields and also attach method on struct!

This input will be automatically unmarshaled into a structured type in Swiftybase.

Dot Notation

Swiftybase allows you to access fields from structs, maps, lists, and other data types that contain fields using dot notation. This makes working with structured data intuitive and readable.

Examples

userModel.Name         // Accessing a field from a struct  
myMap.key             // Accessing a value from a map using a static key  
myMap.$dynamicKey     // Accessing a value using a dynamic key (string variable)  
myUserList.[1].Name   // Accessing a specific index in a list and retrieving a field  

Nullable Types

Swiftybase supports nullable types, allowing you to define optional fields that may or may not be present in a request. You can safely access nullable properties using optional chaining (?.) or force unwrap them (!) if you're sure they exist.

Example

• Accessing a nullable property: userDataNullable?.Name
• Force unwrapping a nullable property (not recommended unless certain): userData.SomeProp!

Special Type: Result<T>

Swiftybase introduces a special type called Result<T>, which represents a value that can either be successful or an error. This forces explicit handling of both success and failure cases, making your function stack more reliable.

Example

{
  "result": {
    "error": null,
    "value": {
      "id": 123,
      "name": "Alice"
    }
  }
}

Middleware

Middleware provides powerful control over your API's execution flow, allowing you to run custom logic before or after an API request is processed. middleware is available on all plans in Swiftybase with no limitations.

Defining Middleware

In Swiftybase, middleware is simply a function marked as middleware. You can assign middleware to specific API endpoints, ensuring modular and reusable logic across your application.

How Middleware Works

Middleware functions can be executed at different stages of an API request:

Pre-Middleware

Pre-middleware runs before input validation and before the main API logic executes. This is useful for tasks such as authentication, logging, or request transformations.

Post-Middleware

Post-middleware runs after the function stack has executed but before the response is returned. It can modify or replace the API’s response entirely.

Applying Middleware

Middleware can be applied Per API Endpoint.

This flexibility allows you to enforce security, modify requests/responses, and handle custom logic efficiently across your Swiftybase APIs.