Infrastructure Modules

A family of lightweight node packs you drop into any Redelay app to get generic infrastructure operations as FlowDSL nodes — Redis GET/SET, Mongo find/insert, HTTP request, file read/write, SMS send, FTP upload, and more. Each pack is either a framework-internal subpackage (no extra dep) or its own Go module in its own repository, so you pull in only what you actually use.

At a glance

Wiring pattern

All packs follow the same two-step wiring.

1. Blank-import the manifest so the module registers itself with the framework registry. This makes nodes discoverable from the /modules browser and the FlowDSL Studio:

import (
    _ "github.com/redelay/go-framework/modules/redisops/flowdsl"
    _ "github.com/redelay/go-framework/modules/mongoops/flowdsl"
    _ "github.com/redelay/go-module-http/flowdsl"
    _ "github.com/redelay/go-module-filesys/flowdsl"
    _ "github.com/redelay/go-module-clickhouse/flowdsl"
    _ "github.com/redelay/go-module-postgres/flowdsl"
    _ "github.com/redelay/go-module-rabbitmq/flowdsl"
    _ "github.com/redelay/go-module-sms/flowdsl"
    _ "github.com/redelay/go-module-ftp/flowdsl"
)

2. Register runtime handlers against the flowexec engine, passing whatever client that pack needs. This is what binds a node ID (redisops/set, postgres/query, …) to its Go handler. Do it once at bootstrap:

import (
    redisflow  "github.com/redelay/go-framework/modules/redisops/flowdsl"
    mongoflow  "github.com/redelay/go-framework/modules/mongoops/flowdsl"
    httpflow   "github.com/redelay/go-module-http/flowdsl"
    fsflow     "github.com/redelay/go-module-filesys/flowdsl"
    chflow     "github.com/redelay/go-module-clickhouse/flowdsl"
    pgflow     "github.com/redelay/go-module-postgres/flowdsl"
    rmqflow    "github.com/redelay/go-module-rabbitmq/flowdsl"
    smsflow    "github.com/redelay/go-module-sms/flowdsl"
    ftpflow    "github.com/redelay/go-module-ftp/flowdsl"
    coreflow   "github.com/redelay/go-flowdsl/nodes/core"
    nodesflow  "github.com/redelay/go-flowdsl/nodes"
)

eng := flowexecmod.Current().Engine()

coreflow.Register(eng)                             // stdlib primitives — no client
redisflow.Register(eng, deps.Redis)
mongoflow.Register(eng, deps.DB)
nodesflow.RegisterPublishers(eng, deps.EventBus)   // kafka/nats/redis-stream publish

httpflow.Register(eng)                             // stdlib http.Client
fsflow.Register(eng, os.Getenv("FILESYS_ROOT"))

chflow.Register(eng, chConn)                       // clickhouse.Conn
pgflow.Register(eng, pool)                         // pgxpool.Pool
rmqflow.Register(eng, amqpConn)                    // amqp.Connection
smsflow.Register(eng, smsflow.Config{
    AccountSID: os.Getenv("TWILIO_ACCOUNT_SID"),
    AuthToken:  os.Getenv("TWILIO_AUTH_TOKEN"),
    FromNumber: os.Getenv("TWILIO_FROM"),
})
ftpflow.Register(eng, ftpflow.Config{
    Host: "ftp.example.com", User: "me", Password: os.Getenv("FTP_PASS"),
})

Skip any module you don't need — the pattern is always the same.

core

Package: go-flowdsl/nodes/core (own Go submodule under go-flowdsl) · Factory: core-flowdsl · 39 nodes

Pure, stdlib-only primitives. No I/O, no client, no credentials.

Extension context keys (wire sinks from your app):

• core.AuditSinkKey — custom audit writer
• core.MetricSinkKey — Prometheus/OTel bridge
• core.DeadLetterKey — DLQ sink
• core.KVStoreKey — backing store for idempotency-key and rate-limit-check (a Redis-backed adapter is a ~30-line wrapper)
• core.WebhookResponderKey — http.ResponseWriter forwarded into core/webhook-respond

events

Package: go-flowdsl/nodes (own Go submodule) · Factory: events-flowdsl · 6 nodes

Event-bus bridges: ingest JSON from any stream, map to typed events, publish over any transport.

The publish handlers are thin wrappers around EventBus.Publish — the wiring transport (Kafka / NATS / Redis / memory) is picked at bootstrap via TRANSPORT env.

redisops

Package: go-framework/modules/redisops/flowdsl · Factory: redisops-flowdsl · 10 nodes

Reuses ModuleDeps.Redis — zero extra config if you already run Redis.

mongoops

Package: go-framework/modules/mongoops/flowdsl · Factory: mongoops-flowdsl · 6 nodes

Collection name is per-node via settings. Reuses ModuleDeps.DB.

storage (S3)

Package: go-modules/storage/flowdsl · Factory: storage-flowdsl · 8 nodes

Existing storage-upload, storage-download, storage-delete, storage-presign-url plus:

Backed by MinIO client — works against AWS S3, Cloudflare R2, MinIO, Backblaze B2, etc.

http

Package: github.com/redelay/go-module-http · Factory: http-flowdsl · 5 nodes · stdlib only

import httpflow "github.com/redelay/go-module-http/flowdsl"
httpflow.Register(eng)

filesys

Package: github.com/redelay/go-module-filesys · Factory: filesys-flowdsl · 5 nodes · stdlib only

All paths are sandboxed to the root passed into Register(eng, root) (or FILESYS_ROOT). Escapes via .. are rejected.

clickhouse

Package: github.com/redelay/go-module-clickhouse · Factory: clickhouse-flowdsl · 3 nodes

import chflow "github.com/redelay/go-module-clickhouse/flowdsl"
conn, _ := clickhouse.Open(&clickhouse.Options{Addr: []string{chHost}})
chflow.Register(eng, conn)

postgres

Package: github.com/redelay/go-module-postgres · Factory: postgres-flowdsl · 4 nodes

Uses jackc/pgx/v5 pgxpool. Pass a pool created once at bootstrap.

rabbitmq

Package: github.com/redelay/go-module-rabbitmq · Factory: rabbitmq-flowdsl · 3 nodes

Uses rabbitmq/amqp091-go. Pass an open amqp.Connection.

sms

Package: github.com/redelay/go-module-sms · Factory: sms-flowdsl · 1 node · stdlib only

Credentials passed once through smsflow.Config{AccountSID, AuthToken, FromNumber}. Per-node fromOverride supported.

ftp

Package: github.com/redelay/go-module-ftp · Factory: ftp-flowdsl · 6 nodes

Uses jlaffaye/ftp for FTP and pkg/sftp with golang.org/x/crypto/ssh for SFTP. Both flavours share a single Config{Host, User, Password, SSHPrivateKey} — supply SSHPrivateKey to use key auth on SFTP.

Regenerating the node catalog

Every page under /docs/nodes is auto-generated from the live flowdsl/module.yaml manifests. Regenerate after adding nodes:

make gen-docs

This walks the monorepo for flowdsl/module.yaml files and emits one page per node with a settings table, inputs/outputs, and an example YAML snippet.