Skip to content

Latest commit

 

History

History
109 lines (78 loc) · 4.11 KB

README.md

File metadata and controls

109 lines (78 loc) · 4.11 KB

Trading Workflow Monorepo

A monorepo for building and running automated trading workflows. It includes:

  • Frontend (apps/frontend) – React + Vite UI with a canvas (React Flow) to assemble trigger/action nodes, manage workflows, and view executions.
  • Backend (apps/backend) – Express API with JWT auth, MongoDB persistence, and Zod validation for workflows, users, and nodes.
  • Executor (apps/executor) – Worker that polls workflows, evaluates trigger nodes, and executes action nodes (trading logic stubbed for now).
  • Shared packages (packages/common, packages/db) – Zod schemas/types, metadata, and Mongoose models reused across apps.

Features

  • Create and visualize workflows composed of trigger and action nodes.
  • User signup/signin with JWT-based authorization.
  • Persist workflows, nodes, and execution history in MongoDB.
  • Executor loop that schedules executions (e.g., timer trigger) and runs action handlers.
  • Type-safe contracts across services via shared Zod schemas and Mongoose models.

Repository layout

  • apps/frontend – React UI (Vite). Scripts: bun run dev, bun run build, bun run lint.
  • apps/backend – Express API server. Entry: index.ts.
  • apps/executor – Background worker. Entry: index.ts.
  • packages/common – Shared types/metadata (e.g., workflow schemas, supported assets).
  • packages/db – Mongoose models for users, workflows, nodes, executions.
  • packages/eslint-config, packages/typescript-config – Shared tooling presets.

Prerequisites

  • Node.js 18+
  • Bun 1.3.x
  • MongoDB instance (local or remote)

Installation

bun install

The workspace is managed with Bun workspaces (see package.json), so a single install at the repo root resolves all app and package dependencies.

Environment variables

Create a .env in each runtime app (apps/backend, apps/executor, apps/frontend) with the values you need. Typical vars:

Backend / Executor:

MONGO_URL=mongodb://localhost:27017/trading-workflows
JWT_SECRET=super-secret-key
PORT=3000            # optional, backend only (defaults to 3000)

Frontend:

VITE_API_URL=http://localhost:3000

Running the stack (local)

In separate terminals:

# Backend API
cd apps/backend
bun run index.ts

# Executor worker
cd apps/executor
bun run index.ts

# Frontend (runs on Vite default 5173)
cd apps/frontend
bun run dev -- --host

Then open the frontend (http://localhost:5173 by default) and point it to the backend URL via VITE_API_URL.

API highlights (backend)

  • POST /signup – create user
  • POST /signin – login, returns JWT token
  • POST /workflow – create workflow (auth required)
  • PUT /workflow/:workflowId – update workflow (auth required)
  • GET /workflow/:workflowId – fetch workflow (auth required)
  • GET /workflows – list user workflows (auth required)
  • GET /workflow/executions/:workflowId – list executions (auth required)
  • GET /nodes – list available node definitions

Requests are validated with Zod schemas from packages/common/types.

Execution model (worker)

  • Connects to MongoDB and fetches workflows.
  • Detects trigger nodes (e.g., timer) and schedules executions.
  • Runs execute for downstream action nodes (e.g., lighter), where trading logic can be implemented (apps/executor/executors/lighter.ts currently stubbed).
  • Records execution status and timestamps in the Executions collection.

Development notes

  • Use bun run format at the repo root to format Markdown/TS/TSX.
  • Root scripts (package.json) also include lint, dev, build, and check-types via Turbo if you add per-package targets.
  • Shared schemas/types live in packages/common; reuse them across services to keep API contracts consistent.

Roadmap ideas

  • Implement real trading logic in apps/executor/executors/lighter.ts (and add more action handlers).
  • Add secure password hashing for auth.
  • Seed node definitions in MongoDB for actions/triggers exposed by the UI.
  • Add tests and CI for API and executor flows.