# FlowSetu — Complete Documentation

> AI-powered integration platform that generates production-ready Spring Boot code.
> Website: https://flowsetu.com

---

## PRODUCT OVERVIEW

FlowSetu is a visual integration platform for developers. You design data flows in a drag-and-drop IDE, and FlowSetu generates clean, readable Spring Boot Java code that you deploy and own forever — no SaaS runtime, no vendor lock-in.

### Core value proposition
- You design visually → FlowSetu generates production-ready Spring Boot code
- The generated code is standard Java/Spring Boot — you own it, modify it, run it anywhere
- No recurring runtime cost: pay for the tool, not the execution
- FlowScript expression language for data transformation

### Who it replaces
- MuleSoft (for teams who want Spring Boot code, not ESB lock-in)
- Zapier / Make (for developers who need code ownership and self-hosting)
- Dell Boomi (for enterprise integrations without SaaS runtime fees)
- Hand-written Spring Integration / Apache Camel boilerplate

---

## FLOWSCRIPT EXPRESSION LANGUAGE

FlowScript is FlowSetu's built-in expression language for transforming data. FlowSetu's own expression language for data transformation inside flows.

### Script structure

Every FlowScript transform has three parts:

```
input payload application/json
output application/json
---
<expression>
```

- `input payload <mime>` — declares input variable and format
- `output <mime>` — declares output serialisation format
- `---` — body separator; expression below this line

### Supported MIME types

- `application/json` — JSON (default)
- `text/csv` — CSV (parsed to array of row objects)
- `application/xml` — XML (parsed to object tree)
- `text/plain` — plain string
- `application/java` — raw Java object passthrough

### Array operators

```
// map — transform every element
payload.items map (item) -> { name: item.productName, price: item.unitPrice }

// filter — keep matching elements
payload.orders filter (o) -> o.status == "shipped"

// orderBy — sort by key expression
payload.products orderBy (p) -> p.price

// groupBy — group into object of arrays
payload.transactions groupBy (t) -> t.type

// distinctBy — deduplicate by key
payload.events distinctBy (e) -> e.id
```

### String operators

```
// concatenation
"Hello, " ++ name ++ "!"

// string interpolation (FlowScript+ extension)
"Order $(payload.orderId) for $(payload.customer.name)"
```

### Pipeline operator (FlowScript+ extension)

```
payload.products
  filter (p) -> p.inStock
  |> orderBy (p) -> p.price
  |> map (p) -> { name: p.name, price: p.price }
```

### Pattern matching

```
fun grade(score) = score match {
  case s if s >= 90 -> "A"
  case s if s >= 80 -> "B"
  case s if s >= 70 -> "C"
  otherwise -> "F"
}
```

### Function definitions

```
input payload application/json
output application/json
---
fun fullName(user) = user.firstName ++ " " ++ user.lastName
fun isAdult(user) = user.age >= 18

payload.users
  filter (u) -> isAdult(u)
  map (u) -> { name: fullName(u), email: u.email }
```

### Type coercion

```
row.age as Number          // "30" → 30
row.amount as String       // 99.5 → "99.5"
row.active as Boolean      // "true" → true
```

### Conditionals

```
// ternary
score >= 50 ? "pass" : "fail"

// if/else
if (amount > 1000) "large" else if (amount > 100) "medium" else "small"

// default (null coalescing)
payload.nickname default payload.firstName
```

---

## CONNECTORS REFERENCE

### HTTP Listener
Creates a REST API endpoint in the generated Spring Boot app.

Configuration:
- `path` — URL path (e.g. `/api/orders`)
- `method` — GET, POST, PUT, DELETE, PATCH
- `responseType` — JSON, XML, plain text

Generated code: Spring Boot `@RestController` with the configured method and path.

### HTTP Request
Makes outbound HTTP calls to external APIs.

Configuration:
- `url` — target URL (supports FlowScript expressions)
- `method` — HTTP method
- `headers` — key-value map
- `body` — request body (supports FlowScript transform)
- `timeout` — milliseconds

### JDBC / SQL Connector
Connects to relational databases. Supports MySQL, PostgreSQL, Oracle, SQL Server, H2.

Operations:
- **SELECT** — query rows, result available as `payload` array
- **INSERT** — insert a record
- **UPDATE** — update matching records
- **DELETE** — delete matching records
- **Stored Procedure** — call a stored procedure

Configuration: JDBC URL, username, password, driver class. Generated as Spring `DataSource` bean with HikariCP connection pool.

### Snowflake Connector
Connects to Snowflake data warehouse.

Configuration:
- Account identifier, username, password
- Warehouse, database, schema
- Role

Operations: SELECT queries, INSERT, MERGE. Generated code uses the Snowflake JDBC driver.

### Salesforce Connector
Connects to Salesforce CRM via REST API.

Configuration:
- Login URL (login.salesforce.com or test.salesforce.com)
- Username, password, security token
- API version

Operations:
- **SOQL Query** — run any SOQL query
- **Insert** — create records
- **Update** — update by ID
- **Upsert** — upsert by external ID field
- **Delete** — delete by ID
- **Bulk Query** — query large datasets using Bulk API 2.0

### HubSpot Connector
Connects to HubSpot CRM.

Configuration: Private App access token.

Operations:
- Contacts: get, create, update, search
- Companies: get, create, update
- Deals: get, create, update
- Custom object operations

### SFTP Connector
Connects to SFTP servers for file transfer.

Configuration: host, port (default 22), username, password or private key.

Operations:
- **Read** — read file content (text or binary)
- **Write** — write/overwrite a file
- **Append** — append to a file
- **List** — list directory contents
- **Delete** — delete a file
- **Move** — rename or move a file

### FTP Connector
Like SFTP but for plain FTP servers. Configuration: host, port (default 21), username, password, passive mode.

### Local File Connector
Read and write files on the local filesystem of the deployed app.

Operations: read (text/binary), write, append, list directory, delete.

### Email / SMTP Connector
Send emails from flows.

Configuration: SMTP host, port, username, password, TLS mode.

Operation: Send email with to, cc, bcc, subject, body (text or HTML), attachments.

### Document Parser Connector
Extract text from PDFs and images using Apache PDFBox and Tesseract OCR — entirely in-process in the generated Spring Boot app.

Configuration:
- `language` — OCR language code (en, hi, fr, de, etc.)
- `dpi` — image resolution for OCR (default 300)
- `timeout` — seconds

Operations:
- **Extract text from PDF** — native text extraction via PDFBox (fast, no OCR needed)
- **OCR PDF** — render PDF pages as images then run Tesseract OCR
- **OCR Image** — run Tesseract OCR on an image file (PNG, JPG, TIFF, BMP)

Generated dependencies: `pdfbox 3.0.2`, `tess4j 5.9.0`.
Language models auto-downloaded from tessdata_fast on first use and cached at `~/.flowsetu/tessdata/`.

---

## CORE CONCEPTS

### Flows
A flow is a sequence of steps that process a message. Every flow has:
- One trigger (HTTP Listener, scheduler, file watcher, or message queue)
- One or more processing steps
- Optional error handling

### Subflows
Reusable sequences of steps that can be called from any flow. Generated as private Spring methods.

### Error Handling
- **Try / Catch** — wrap steps in error handling; catch specific exception types
- **On Error Continue** — log the error and continue processing
- **On Error Propagate** — rethrow the error

### Choice / Routing
Conditional branching. Each branch has a FlowScript condition expression. First matching branch executes. Optional default branch.

### For Each (Parallel)
Iterate over an array and process each element. Optionally run in parallel threads. Generated as Spring `@Async` with configurable thread pool.

### Transform step
Apply a FlowScript expression to reshape `payload`. The result becomes the new `payload` for the next step.

### Global Config
Shared connection configuration (database URLs, API keys, etc.) defined once and referenced by connectors throughout flows.

---

## CODE GENERATION

FlowSetu generates a standard Maven Spring Boot 3.x project.

### Generated project structure

```
<projectName>/
├── pom.xml
├── src/main/java/<package>/
│   ├── <ProjectName>Application.java
│   ├── flow/
│   │   ├── FlowService.java          # main flow orchestration
│   │   └── SubflowService.java       # subflows
│   ├── connector/
│   │   ├── SftpClient.java
│   │   ├── SalesforceClient.java
│   │   └── ...
│   └── config/
│       └── AppConfig.java
└── src/main/resources/
    └── application.yml
```

### Running the generated project

```bash
# Prerequisites: Java 17+, Maven 3.8+
cd <projectName>
mvn spring-boot:run

# Or build a fat JAR
mvn package
java -jar target/<projectName>-0.0.1-SNAPSHOT.jar
```

### Customising pom.xml
The generated `pom.xml` is fully standard. Add any Maven dependency, change the Spring Boot version, add plugins. FlowSetu does not modify the pom after export.

---

## COMPARISON WITH ALTERNATIVES

### FlowSetu vs MuleSoft

MuleSoft is a mature enterprise ESB. FlowSetu targets teams who want to migrate away from MuleSoft or avoid its pricing.

| Dimension | FlowSetu | MuleSoft |
|---|---|---|
| Runtime model | Generated Spring Boot (you own it) | Mule ESB runtime (SaaS) |
| Pricing | Free tier available | $$$$ enterprise licensing |
| Code ownership | Full ownership of generated Java | No — runs on Mule runtime |
| Spring Boot output | Yes | No |
| Expression language | FlowScript (FlowSetu-native) | Proprietary ESB scripting |
| Migration path | Purpose-built MuleSoft migration tool | N/A |
| Learning curve | Low (visual + familiar Spring Boot) | High |

### FlowSetu vs Zapier

Zapier is a no-code automation tool. FlowSetu targets developers who need code ownership and enterprise data volume.

| Dimension | FlowSetu | Zapier |
|---|---|---|
| Target user | Developers / engineers | Non-technical users |
| Code output | Spring Boot Java | None |
| Self-hostable | Yes (generated code runs anywhere) | No |
| Data volume | Unlimited (your infrastructure) | Rate-limited by plan |
| Custom logic | Full Java + FlowScript | Limited |
| Price at scale | Fixed (own infrastructure) | Per-task pricing |

### FlowSetu vs n8n

n8n is an open-source workflow automation tool. FlowSetu generates Spring Boot code; n8n runs workflows on its own runtime.

| Dimension | FlowSetu | n8n |
|---|---|---|
| Output | Spring Boot code | n8n workflow JSON |
| Runtime | Your JVM (generated code) | n8n runtime (self-hosted or cloud) |
| Language | Java / Spring Boot | Node.js |
| MuleSoft migration | Yes | No |
| Enterprise Java integration | First-class | Limited |
| Code review / audit | Standard Java code review | Workflow JSON audit |

### FlowSetu vs Dell Boomi

Dell Boomi is an enterprise iPaaS. FlowSetu targets teams who want Spring Boot output instead of Boomi's proprietary runtime.

| Dimension | FlowSetu | Dell Boomi |
|---|---|---|
| Runtime | Generated Spring Boot | Boomi Atom runtime |
| Vendor lock-in | None | High |
| Pricing | Free tier | Enterprise contracts |
| Java output | Yes | No |
| On-premise deploy | Yes (generated code) | Atom worker required |

---

## FREQUENTLY ASKED QUESTIONS

**What is FlowSetu?**
FlowSetu is an AI-powered visual integration platform that generates production-ready Spring Boot Java code. You design flows visually, FlowSetu generates the code, and you own and deploy it forever.

**Is FlowSetu free?**
Yes, FlowSetu has a free tier. No credit card required to start building.

**Do I need to know Java to use FlowSetu?**
No, to design flows. But the generated code is Java/Spring Boot, so knowing Java helps you customise and extend the generated project.

**What makes FlowSetu different from MuleSoft?**
FlowSetu generates Spring Boot code you own. MuleSoft requires you to run flows on the Mule ESB runtime — a closed, expensive SaaS. FlowSetu output is standard Java, deployable anywhere, with no ongoing runtime fee.

**Can I migrate my MuleSoft flows to FlowSetu?**
Yes. FlowSetu has a migration studio designed to help teams move from MuleSoft to Spring Boot. FlowSetu's FlowScript language is designed to make that transition straightforward.

**What databases does FlowSetu support?**
MySQL, PostgreSQL, Oracle, SQL Server, H2 (in-memory), and Snowflake via dedicated connectors.

**Can FlowSetu handle large data volumes?**
Yes. Salesforce connector supports Bulk API 2.0. SFTP/FTP connectors stream files. The generated Spring Boot code runs on your infrastructure with no SaaS-imposed rate limits.

**What is FlowScript?**
FlowScript is FlowSetu's built-in expression language for transforming data inside flows. FlowSetu's own expression language for data transformation. It supports map, filter, groupBy, pattern matching, function definitions, and more.

**Can I use FlowSetu for SFTP automation?**
Yes. FlowSetu's SFTP connector supports read, write, list, delete, and move operations with full FlowScript transformation. It's commonly used to replace WinSCP scripts or legacy SFTP automation.

**How do I run the generated project?**
The generated project is a standard Maven Spring Boot app. Run `mvn spring-boot:run` or build a fat JAR with `mvn package` and run `java -jar target/*.jar`. Java 17+ and Maven 3.8+ required.

---

## SITEMAP

- https://flowsetu.com/ — Home
- https://docs.flowsetu.com — Documentation hub
- https://docs.flowsetu.com/introduction — What is FlowSetu?
- https://docs.flowsetu.com/first-flow — Your first flow
- https://docs.flowsetu.com/flowscript — FlowScript syntax reference
- https://docs.flowsetu.com/flowscript/functions — FlowScript function reference
- https://docs.flowsetu.com/connectors/http-listener — HTTP Listener connector
- https://docs.flowsetu.com/connectors/http-request — HTTP Request connector
- https://docs.flowsetu.com/connectors/database — JDBC / SQL connector
- https://docs.flowsetu.com/connectors/snowflake — Snowflake connector
- https://docs.flowsetu.com/connectors/salesforce — Salesforce connector
- https://docs.flowsetu.com/connectors/hubspot — HubSpot connector
- https://docs.flowsetu.com/connectors/sftp — SFTP connector
- https://docs.flowsetu.com/connectors/ftp — FTP connector
- https://docs.flowsetu.com/connectors/local-file — Local File connector
- https://docs.flowsetu.com/connectors/email — Email / SMTP connector
- https://docs.flowsetu.com/connectors/document-parser — Document Parser connector
- https://flowsetu.com/mulesoft-alternative — MuleSoft alternative
- https://flowsetu.com/sftp-client-online — SFTP client online
- https://flowsetu.com/vs/zapier — FlowSetu vs Zapier
- https://flowsetu.com/vs/n8n — FlowSetu vs n8n
- https://flowsetu.com/vs/boomi — FlowSetu vs Dell Boomi
- https://flowsetu.com/connectors — All connectors
- https://flowsetu.com/pricing — Pricing
- https://flowsetu.com/contact — Contact