Store and query entities whose shape changes often, on PostgreSQL, without writing DDL migrations.
Forma is a data management service and Go library. You describe each entity type
with a JSON Schema file; Forma validates writes against it and stores the data in
PostgreSQL in a fixed set of tables: frequently used attributes in typed, indexable
columns of a main table, everything else in an entity-attribute-value (EAV) table.
Adding or removing an attribute is a schema-file change, not an ALTER TABLE.
An optional analytical tier exports the data to Parquet on S3 and answers queries
with DuckDB, merging in the rows PostgreSQL has not exported yet.
Forma is pre-1.0 (latest tag v0.2.0). PostgreSQL 16 is the supported database;
Aurora DSQL support is implemented but has not yet run against a real cluster
(details).
- Why Forma?
- Key features
- Quick Start
- How it works
- HTTP API
- Consistency and compatibility
- Configuration
- Development and testing
- Documentation
- Contributing, support and license
A conventional relational schema gives you types, constraints and indexes, but every new field is a migration. A document or schema-less store makes new fields free but gives up declared types and validation. Forma sits between the two:
| Conventional tables | Forma | |
|---|---|---|
| Add an attribute | ALTER TABLE migration |
Edit the JSON Schema, record it with apply-schema, restart |
| Validation | Column types and constraints | JSON Schema validation of writes, plus declared value types |
| Indexed access | Any column | Attributes bound to typed main-table columns; EAV attributes are not indexable |
| Analytics | A separate pipeline | Optional CDC export to Parquet, queried through DuckDB |
The costs are real. EAV reads are more complex than reading one row, so Forma
generates CTE + JSON_AGG SQL that fetches a page of entities and their attributes
in one statement instead of one query per entity. The main table has a fixed set
of typed columns, so only some attributes can be column-bound and indexed. And
schema changes are not free-form: changing an existing attribute's type is allowed
only when it is lossless for stored data, and refused otherwise
(Schema Evolution).
Forma fits when:
- Entity shapes change often. The bundled sample schemas (
cmd/server/schemas/) model a CRM — leads, contacts, visits, activities — whose fields grow over time. - A Go service needs multi-entity transactional workflows.
Transactor.InTxruns reads and writes across schemas in one PostgreSQL transaction, with preconditions, upserts on unique keys, andTx.Claimfor work-queue style consumers (Transactions, Claims). - The same entities need analytical scans without a separate ETL pipeline, through the optional CDC + Parquet + DuckDB tier described below.
Forma is not a replacement for a general-purpose relational database or a data warehouse: callers use its entity API rather than SQL, queries filter one schema at a time (search spans several), and offset pagination is capped at a configurable depth.
- JSON Schema data modeling. Each schema is a JSON Schema file plus a generated
<schema>_attributes.jsonthat assigns attribute IDs, value types and, optionally, a main-table column. A create that violates the schema answers400naming the attribute. An update that violates it is logged and written unlessVALIDATE_UPDATES_STRICTis set, so rows stored before enforcement stay updatable (Error Handling). - Hybrid storage. Column-bound attributes live in typed columns of
entity_main; the rest live ineav_data. Column-bound attributes can carry declared composite indexes (x-forma-indexes) and unique keys (x-forma-unique-keys). - Schema evolution without DDL. Adding, removing and renaming attributes, safe widenings, and promoting an EAV attribute to a column are recorded as a new schema generation. Narrowing or cross-type changes are refused; explicit data migrations are not implemented yet (#730) (Schema Evolution).
- CRUD, batches and queries. Create, read, update, delete and atomic batches over
HTTP or Go; paginated queries with a condition DSL
(comparisons,
in,contains, null tests,and/or); cross-schema text search. - Transactions (Go API).
Transactor.InTx, row fences, conditional writes (Conditional Writes), predicate updates/deletes and claims. There is no HTTP transaction endpoint (deferred to #656). - CDC to Parquet and federated queries (optional).
cdc-flushexports changed rows to S3 Parquet,compactormerges them into base files, and on a server that enables DuckDB a query can be answered by DuckDB over Parquet merged with unexported PostgreSQL rows. Off by default; see limitations. - Deployment entry points. An HTTP server (
cmd/server), an AWS Lambda handler for API Gateway HTTP APIs (cmd/lambda), an operations CLI (cmd/tools), and the Go packagesformaandfactoryfor embedding.
This runs Forma against a local PostgreSQL 16 with the bundled sample schemas, then creates and reads one record. It needs no S3, DuckDB setup, or cloud account.
Prerequisites
- Go 1.26+ and a C toolchain (the server links DuckDB through CGO). The Makefile pins
GOTOOLCHAIN=go1.26.0+auto, so a newer local Go downloads go1.26.0 once. - Docker or Podman with Docker Compose.
curl.
git clone https://github.com/Lychee-Technology/forma.git
cd forma
./scripts/local_server.shThe script starts the Compose stack, rebuilds the binaries (make clean build-all),
runs init-db, brings the schema generation ledger in step with cmd/server/schemas
(baseline-schema, apply-schema), and runs the server on :8080 in the
foreground. Ctrl-C stops the server and the containers; the PostgreSQL data stays
in deploy/data/.
git clone https://github.com/Lychee-Technology/forma.git
cd forma
# PostgreSQL 16 on :5432 (postgres/postgres) and RustFS, an S3-compatible
# store on :9000 that only the optional CDC/federated tier uses.
docker compose -f deploy/docker-compose.yml up -d --wait
make build-all
# Create the tables and register the sample schemas. The table names match
# the server's defaults; init-db's own defaults differ.
./build/tools init-db \
--db-host localhost --db-port 5432 --db-name forma \
--db-user postgres --db-password postgres --db-ssl-mode disable \
--schema-table schema_registry_dev \
--eav-table eav_data_dev \
--entity-main-table entity_main_dev \
--change-log-table change_log_dev \
--schema-dir cmd/server/schemas
DB_PASSWORD=postgres SCHEMA_DIR=cmd/server/schemas ./build/serverinit-db on a database it already initialized is safe to rerun. After you edit a
schema file, record the change with ./build/tools apply-schema (same connection
flags plus --schema-table and --schema-dir) before restarting the server, which
refuses to start on a declaration the database has not recorded. local_server.sh
does this on every run.
In another terminal, check the server and create a contact
(cmd/server/schemas/contact.json requires id and email):
curl -s localhost:8080/health
# {"status":"healthy"}
curl -s -X POST localhost:8080/api/v1/contact \
-H 'Content-Type: application/json' \
-d '{"id":"c-001","name":"Ada Lovelace","email":"ada@example.com","company":"Analytical Engines"}'The response is the stored record. row_id is generated, so yours differs:
{"schema_name":"contact","row_id":"01a1de4d-6280-7a3a-8bbd-87372bc8ad60","attributes":{"company":"Analytical Engines","email":"ada@example.com","id":"c-001","name":"Ada Lovelace"}}Read it back by row_id, update one attribute, and list the schema:
ROW_ID=<row_id from the response>
curl -s localhost:8080/api/v1/contact/$ROW_ID
curl -s -X PUT localhost:8080/api/v1/contact/$ROW_ID \
-H 'Content-Type: application/json' -d '{"phone":"+44 20 7946 0000"}'
curl -s 'localhost:8080/api/v1/contact?items_per_page=5'PUT merges the given attributes into the record. A write that violates the schema,
such as {"id":"c-002","email":"not-an-email"}, answers 400 with
{"success":false,"error":"... validating /properties/email: pattern ..."}.
Clean up: stop the server, then
docker compose -f deploy/docker-compose.yml down. To start from an empty database,
also remove deploy/data/ (it is owned by the container's postgres user, so it may
need sudo).
flowchart LR
app["HTTP client or Go application"]
files["JSON Schema +<br/>attributes files"]
forma["Forma<br/>(server, Lambda or Go library)"]
pg[("PostgreSQL<br/>entity_main · eav_data<br/>change_log · schema registry")]
delta[("S3 Parquet<br/>/delta/")]
base[("S3 Parquet<br/>/base/")]
duck["DuckDB<br/>(embedded)"]
files -- "loaded at start" --> forma
app --> forma
forma -- "writes: one transaction" --> pg
forma -- "Get, Query, Search" --> pg
pg -. "cdc-flush (batch job)" .-> delta
delta -. "compactor" .-> base
forma -. "federated Query (DUCKDB_ENABLED)" .-> duck
duck -.-> delta
duck -.-> base
- Write path. Forma validates the payload against the JSON Schema, maps each
attribute to its column or EAV row through the attributes file, and writes
entity_main,eav_dataand achange_logentry in one PostgreSQL transaction. S3 is never part of a write. - Read path.
Get, cross-schema search and, on a server without DuckDB,Queryread PostgreSQL, which always holds the complete current state of every live entity. - CDC and the Parquet tiers (optional).
forma-tools cdc-flushexports rows whosechange_logentry is unflushed to Parquet under/delta/, records them in an S3 manifest, then marks them flushed.forma-tools compactormerges delta files into/base/. Both run as separate jobs. - Federated query (optional). DuckDB reads the Parquet tiers while Forma reads the
still-unflushed ("hot") rows from PostgreSQL in one snapshot. Any Parquet row whose
row_idis still unflushed is discarded in favor of the PostgreSQL version; tiers are reconciled by this anti-join, never by comparing timestamps.
Federated query design covers tiers, the anti-join, manifests, degraded modes and the numeric and naming contracts in depth.
All paths are under /api/v1. Success bodies are the record or result itself; errors
are {"success": false, "error": "..."} with a 4xx or 5xx status
(Error Handling).
| Method | Path | Description |
|---|---|---|
GET |
/health |
Liveness check |
POST |
/api/v1/{schema} |
Create one record (object body) or several atomically (array body) |
GET |
/api/v1/{schema}/{row_id} |
Get one record (?attrs= projects attributes) |
GET |
/api/v1/{schema} |
List records (?page=&items_per_page=&sort_by=&sort_order=&attrs=) |
PUT |
/api/v1/{schema}/{row_id} |
Update a record, merging the given attributes |
DELETE |
/api/v1/{schema}/{row_id} |
Delete one record |
DELETE |
/api/v1/{schema} |
Delete several records (body: JSON array of row_id strings) |
GET |
/api/v1/search |
Cross-schema search (?schemas=a,b&q=&page=&items_per_page=) |
POST |
/api/v1/advanced_query |
Query with the condition DSL (JSON body) |
An advanced query against the Quick Start data:
curl -s -X POST localhost:8080/api/v1/advanced_query \
-H 'Content-Type: application/json' \
-d '{"schema_name":"contact","page":1,"items_per_page":10,
"condition":{"l":"and","c":[
{"a":"email","v":"contains:@example.com"},
{"a":"company","v":"starts_with:Analytical"}]}}'List, search and advanced-query responses share one shape:
{"data":[...],"total_records":1,"total_pages":1,"current_page":1,"items_per_page":10,"has_next":false,"has_previous":false,...}.
Pagination is offset-based. items_per_page is capped at 100, and a page whose
window (page × items_per_page) ends past MAX_QUERY_ROWS rows (10000 by default)
answers 400 instead of scanning every earlier row; to read further, narrow the
query with a condition, for example on the sort attribute past the last row read.
A date or datetime attribute is returned as an RFC 3339 string when its year is
0000 to 9999, and otherwise as a string of its exact epoch milliseconds (for example
"9223372036854775807"), which a create or update accepts back unchanged (#591).
Transactions, conditional writes, upserts, claims and batch updates are available only
through the Go API. Start from Transactions and from
cmd/server/main.go, which shows how factory.NewEntityManagerWithConfigContext is
wired from a forma.Config, a pgxpool.Pool and a schema registry.
Each read API has a minimum guarantee, whichever execution path answers it (design §3.3):
| API | Guarantee |
|---|---|
GET /api/v1/{schema}/{row_id} (Get) |
Read-after-write: once a create, update or delete has returned, every later Get sees it. A record's attributes come from one snapshot; relation fields are fetched separately and can reflect a different commit. Always served by PostgreSQL, so it fails if PostgreSQL is unavailable. |
GET /api/v1/{schema}, POST /api/v1/advanced_query (Query) |
Eventually consistent: an answer converges on committed state once CDC catches up. No path deliberately serves a stale version, and a deleted row does not reappear. Fails if PostgreSQL is unavailable. Served by PostgreSQL, or on a federated server by PostgreSQL and DuckDB over Parquet (below). |
GET /api/v1/search (CrossSchemaSearch) |
Eventually consistent. Served by PostgreSQL only. |
Tx.Get, Tx.Query (Go API) |
See the transaction's own writes, at READ COMMITTED on PostgreSQL and REPEATABLE READ on aurora-dsql (Transactions). |
No read is serializable.
Federation is a deployment decision, not a request option
(federated query controls).
On a server started with DUCKDB_ENABLED=true and S3 settings, every
GET /api/v1/{schema} and POST /api/v1/advanced_query enters the federated engine,
and its routing strategy decides whether DuckDB reads the Parquet tiers that CDC
writes or PostgreSQL answers alone. Both return the same rows. Without DUCKDB_ENABLED, every query runs on
PostgreSQL. Get, search and Go Tx reads always read PostgreSQL. A request can only
ask to see the route: "include_execution_plan": true in the advanced-query body
returns execution_plan, on a federated server only.
The request-level federated block was removed in #715 without a compatibility
period. The server ignores unknown JSON fields, so a client still sending it gets the
server's route; Go code that sets QueryRequest.Federated no longer compiles.
Limitations to know before relying on it:
- With the default
hybridrouting, a page smaller than 1000 rows (every API page) is answered from PostgreSQL alone unless its offset is 10000 or more, which the defaultMAX_QUERY_ROWSrefuses. A server on the defaults therefore never reads Parquet; setDUCKDB_ROUTING_STRATEGYtofreshness-firstorcost-firstto read it. - A schema with an attribute inside an array of objects (the sample
leadhas two) cannot be represented in Parquet: its queries are answered from PostgreSQL, andcdc-flushskips it with a warning (#704). - When S3 or DuckDB fails, or a Parquet object is corrupt, the query fails; with
DUCKDB_ALLOW_PARTIAL_DEGRADED_MODEit is answered from PostgreSQL alone (design §7.2, §7.3). That answer is complete, but during an S3 outage it moves every scan onto PostgreSQL. The response does not mark it; the log line "federated query degraded to postgres-only", thefederated_degraded_fallback_totalmetric and the execution plan's routing reason do. - On a federated server a sort on a list attribute is refused (
400); a PostgreSQL-only server accepts it. - If
DUCKDB_ENABLEDis set and the DuckDB client cannot initialise, the server does not start.
PostgreSQL has advisory locks and makes a conflicting writer wait; Aurora DSQL has
neither and aborts one writer with SQLSTATE 40001 at commit. Forma therefore has one
write-path implementation per engine and does not detect the engine: you configure it,
and every writer and CDC tool of one database must name the same engine.
| Surface | PostgreSQL 16 | Aurora DSQL |
|---|---|---|
Entity writes and Tx (DB_ENGINE, forma.DatabaseConfig.Engine) |
Supported | aurora-dsql; CI runs it on PostgreSQL emulating DSQL and through MiniStack's SQL-validating proxy |
CDC tools' schema lock, flush mark and export reads (--pg-engine) |
Supported | aurora-dsql (a lease row); same CI validation |
| Federated hot-tier reads (pgx) | Supported | Pass in the MiniStack lane (#691) |
init-db |
Supported | Not supported: its DDL is not valid on DSQL (#690); create the tables by hand |
None of the Aurora DSQL paths has run against a real cluster yet. MiniStack and
dsql-lint check SQL validity and behavior through an emulator,
not a cluster's transaction limits or performance.
Aurora DSQL covers what differs, the tables to create by hand,
and how to verify a cluster.
Forma pins DuckDB 2.0.0 through github.com/duckdb/duckdb-go/v2 v2.20000.0, which
requires CGO. The precompiled native library is a separate Go module per platform,
go.duckdb.org/libduckdb/<os>-<arch> (linux and darwin on amd64 and arm64, windows on
amd64), so a restricted GOPROXY or module mirror must serve go.duckdb.org as well
as github.com.
parquet is linked into the engine. httpfs, needed for S3, is not: it downloads from
extensions.duckdb.org into ~/.duckdb/extensions/v2.0.0/ on first use, and a
connection that needs it and cannot load it fails to open
(design §7.5).
No Forma engine loads postgres_scanner; the CDC export transport parity test and the
federated e2e harness's reference queries still do, and it downloads the same way.
A database file DuckDB 2.0 wrote cannot be opened by an older Forma build on DuckDB 1.5.6; the Parquet files it writes to S3 stay readable by 1.5.6. DuckDB upgrades describes that check and what to run for an engine upgrade.
The server is configured through environment variables. The common ones:
| Variable | Default | Description |
|---|---|---|
DB_HOST, DB_PORT, DB_NAME |
localhost, 5432, forma |
PostgreSQL location |
DB_USER, DB_PASSWORD |
postgres, empty |
Credentials; the Compose stack's password is postgres |
DB_SSL_MODE |
disable |
libpq SSL mode |
DB_ENGINE |
postgresql |
Write-path engine: postgresql, or aurora-dsql (Aurora DSQL) |
SCHEMA_DIR |
empty | Directory of schema and attributes JSON files |
SCHEMA_TABLE, EAV_TABLE, ENTITY_MAIN_TABLE, CHANGE_LOG_TABLE |
schema_registry_dev, eav_data_dev, entity_main_dev, change_log_dev |
Table names; must match what init-db created |
PORT |
8080 |
HTTP listen port |
DUCKDB_ENABLED |
false |
Enables the federated engine; its S3 and manifest settings are in design §4.3.1 |
DUCKDB_ROUTING_STRATEGY |
hybrid |
Which queries the federated engine sends through DuckDB: hybrid, cost-first or freshness-first (every query) (design §4.3) |
DUCKDB_ALLOW_PARTIAL_DEGRADED_MODE |
false |
true answers a query from PostgreSQL alone when its DuckDB pass fails degradably, instead of failing it |
METRICS_STDOUT |
unset (off) | true writes every emitted metric as a JSON line on stdout (Telemetry) |
VALIDATE_UPDATES_STRICT |
false |
true rejects updates that violate the schema; by default they are logged and written (Error Handling) |
Pool settings are DB_MAX_CONNECTIONS, DB_MAX_IDLE_CONNS,
DB_CONN_MAX_LIFETIME_SECONDS, DB_CONN_MAX_IDLE_TIME_SECONDS and
DB_TIMEOUT_SECONDS. cmd/tools subcommands take flags whose defaults come from the
same DB_* variables (tools README, in Chinese).
| Variable | Default | Description |
|---|---|---|
MAX_ENTITY_SIZE_BYTES |
1048576 |
Cap on every HTTP request body, trailing bytes included; a larger body answers 413 before it is decoded |
MAX_BATCH_SIZE |
1000 |
Cap on operations per batch create/update/delete; a larger batch answers 400 |
MAX_QUERY_ROWS |
10000 |
How deep offset pagination reaches (see HTTP API); 0 disables |
QUERY_TIMEOUT_SECONDS |
30 |
Budget for a get, query or search; an exceeded budget answers 504 (0 disables) |
TRANSACTION_TIMEOUT_SECONDS |
30 |
Budget for one write transaction (create, update, delete, atomic batch); 0 disables |
DUCKDB_QUERY_TIMEOUT_SECONDS |
30 |
Budget for all the DuckDB work of one federated request, inside the query budget; 0 disables |
HTTP_READ_HEADER_TIMEOUT_SECONDS |
10 |
http.Server ReadHeaderTimeout |
HTTP_READ_TIMEOUT_SECONDS |
30 |
http.Server ReadTimeout (whole request, body included); a body still arriving when it expires answers 408 |
HTTP_WRITE_TIMEOUT_SECONDS |
90 |
http.Server WriteTimeout, armed before the body is read; must exceed HTTP_READ_TIMEOUT_SECONDS plus the largest budget |
HTTP_IDLE_TIMEOUT_SECONDS |
120 |
http.Server IdleTimeout for keep-alive connections |
HTTP_MAX_HEADER_BYTES |
1048576 |
http.Server MaxHeaderBytes |
All configuration is validated before the server opens a database connection, and one failed boot names every bad variable:
- Limits. A negative value, a zero size or batch cap, a non-zero
MAX_QUERY_ROWSbelow the 100-row page cap, or a boundedHTTP_WRITE_TIMEOUT_SECONDSthat does not exceedHTTP_READ_TIMEOUT_SECONDSplus the longest bounded budget (query, or DuckDB when the query budget is0, or transaction) fails startup naming the field. The write deadline starts once the headers are read, so it covers the body upload, the budget and the response; a bounded write timeout therefore needs a bounded read timeout. - Integers. Every integer variable, pool settings included, must be a plain base-10
integer (the
*_SECONDSones a whole number of seconds). Unset or empty takes the default. A value such as30s,1_000or1.5, or a seconds value too large for a Go duration, fails startup of the server and the Lambda cold start, for exampleenvironment variable QUERY_TIMEOUT_SECONDS="30s" must be a whole number of seconds: invalid syntax. - Booleans.
METRICS_STDOUT,VALIDATE_UPDATES_STRICT,DUCKDB_ENABLEDandDUCKDB_ALLOW_PARTIAL_DEGRADED_MODEtaketrue/false,1/0ort/fin any case. Any other value, such asyes,onortruewith a trailing space, fails startup (before #642 it read as false, silently).compactorapplies the same rule toMETRICS_STDOUT, andcmd/sampletoVALIDATE_UPDATES_STRICT.DUCKDB_ALLOW_PARTIAL_DEGRADED_MODE,DUCKDB_ROUTING_STRATEGY(which must name one of its three strategies) and the other DuckDB engine and manifest settings are read only whenDUCKDB_ENABLEDis true, or is itself refused (so one boot names every bad value).DUCKDB_QUERY_TIMEOUT_SECONDSis a limit and is always checked. - Kubernetes. A Service named
dbmakes the kubelet injectDB_PORT=tcp://<ip>:<port>into pods in its namespace. That value is refused rather than read as5432, so setDB_PORTexplicitly or setenableServiceLinks: false.
| Command | What it runs | Needs |
|---|---|---|
make test |
Unit tests (the CI job adds -race) |
Go |
make fmt-check, make lint |
gofmt gate; golangci-lint pinned to v1.64.8, as in CI | Go; network on first run |
make lint-dsql |
Static Aurora DSQL check of the SQL corpus (dsql-lint) | Network on first run to fetch the pinned linter |
./scripts/test_with_container_runtime.sh |
Detects Docker or rootless Podman, configures testcontainers, runs make test |
Docker or Podman |
make test-dsql-ministack |
Aurora DSQL suites through MiniStack's SQL proxy (guide) | Docker; no AWS account |
go test ./internal/e2e_harness/federated/... -tags=e2e -timeout=30m |
Full federated suite: PostgreSQL + S3 + CDC + DuckDB merge-on-read | Docker or Podman |
make test-e2e-production |
Production harness checked against an independent oracle | Docker |
make benchmark-smoke |
Benchmark smoke validation, as in CI | Go |
Direct go test invocations bypass the Makefile's toolchain pin; set it yourself:
GOTOOLCHAIN=go1.26.0+auto go test ./internal/sqlgen -run TestName -vCI (.github/workflows/ci.yml) runs lint, the DSQL lint gate, unit tests, the MiniStack
lane, the e2e smoke and -short federated suite, the production harness, and
benchmark-smoke. -short skips the slowest federated tests; the nightly workflow
runs the full federated suite and the production suite under -race. The
Go E2E harness README and the
E2E test matrix describe the suites.
The Bun E2E suite is a black-box deployment smoke test: against
a running server it registers schemas, generates data, runs cdc-flush and checks the
federated route; it also drives k6 load tests (bun run k6-smoke, k6-full,
k6-perf). It needs Bun, plus k6 or Docker.
make benchmark-regression and make benchmark-heavy run larger benchmark sets;
benchmark-heavy-live and benchmark-concurrency take hours and are operator-run
only. None is needed to validate an ordinary change.
Data modeling
- Schema Evolution and Declared Types: what a declared
valueTypeguarantees and which changes are allowed - Declared Indexes (
x-forma-indexes) - Row IDs and Unique Keys (
x-forma-unique-keys) - Text collation
- Schema Consistency Migration Guide
Reading and writing
- Condition DSL Reference
- Transactions (
Transactor.InTx) - Conditional Writes (
Preconditions,UpdateOps) - Claims (
Tx.Claim) - Error Handling
Federated query and CDC
Aurora DSQL
Testing and development
- E2E Test Matrix and Integration Test Cases
- Go E2E Harness README
- Bun E2E README
- Tools CLI reference (Chinese)
- Coding standard
Report bugs and propose features in GitHub Issues. Before opening a pull request:
- Follow coding-standard.md: files at most 500 lines, functions at
most 100, errors wrapped with context, user-facing write errors built with
forma.InvalidInputfand related carriers (Error Handling). - Run
make fmt-check,make lintandmake test; run the container-based suites above when you change storage, CDC or federated code. - AGENTS.md summarizes the architecture and conventions, and docs/non-code-rules.md describes what issues and PR descriptions should contain.
Use GitHub Issues for questions and bug reports. community.md links the LTBase community Discord channel (Chinese).
Forma is released under the MIT License, © 2025 Lychee Technology Inc.