Entities

The snake_case table name (e.g. blog_posts). This is the source of truth — backend route paths are derived as camelCase (/blogPosts) and the FE endpoint key as UPPER_SNAKE (GET_BLOG_POSTS) automatically.

When true, Nucleus prepends the standard system columns so you don't repeat them: a uuid id primary key, created_at / updated_at timestamps, an is_active soft-delete flag and a version counter for optimistic concurrency.

A logical grouping label used to organise entities in admin UIs and generated docs. Purely organisational.

Expose batch create/update/delete routes for this entity. Bulk-operation claims are only seeded when this is true, keeping the claims table clean for entities that don't need them.

Mark the entity as accepting multipart/form-data (file uploads) rather than JSON — relevant for entities that carry binary payloads.

Tags an entity as belonging to a framework feature (authentication, authorization, audit, payment, storage…). Used internally for the built-in system tables; you rarely set this on your own entities.

Names the backend service that physically owns this entity. The FE endpoint generator uses it to route calls to the right service in a multi-service deployment. Omit for the default/IDP service.

Example: "blog-api"

Runtime dependencies that must be configured for this entity's routes to mount (currently 'email'). Lets system entities stay dormant until their provider exists.

Per-method public access. { "GET": true } makes reads reachable without auth while writes stay protected — exactly what public-facing list/detail pages need.

Example: { "GET": true }

Methods to NOT generate for this entity. Use ["DELETE"] for append-only tables, or omit POST for read-only reference data.

Restrict the entity to specific Postgres schemas. In multi-tenant setups this controls which tenants receive the table.

The inverse — schemas that should NOT receive this entity.

Limit the entity to specific appIds when several services share one schema source, so each service only mounts the tables it owns.

Each entity's columns are compiled into Elysia TypeBox schemas — a request-body schema (notNull → required, types mapped to t.Number/t.Boolean/t.String{format} / t.Unknown for json) and matching response, list, bulk, delete and error schemas. These power both runtime request validation and the auto-generated Swagger/OpenAPI page, so the documented contract and the enforced contract are the same object.

Before a write hits the database the payload is type-checked per column and format-checked against built-in patterns (email, url, uuid, date, datetime, time, uri, ipv4, ipv6), then sanitised to drop unknown/forbidden keys — so malformed or over-posted bodies are rejected, not silently stored.

Your entities don't start from an empty database. Nucleus ships a full set of system tables (users, sessions, roles, claims, role_claims, user_roles, tenants, tenant_features, audit_logs, notifications, verification flows, …) that the auth, RBAC, audit, verification and tenant subsystems own. Your tables are generated alongside them, and feature_set marks an entity as belonging to one of these framework features.

Internally tables are looked up in the schemaTables map by a camelCase key derived from the snake_case table_name (blog_posts → blogPosts). resolveSchemaTable tries the given key, then the normalised form, and warns if neither resolves — preventing the silent undefined that used to bypass role checks.

The field definitions for the table.

Declarative input rules enforced on create/update.

Transforms applied to incoming values before persistence: trim, lowercase, uppercase, escapeHtml, stripTags, normalizeEmail, toNumber, toBoolean, slugify. Chain several to clean input deterministically.

Example: ["trim", "lowercase", "normalizeEmail"]

Each index has columns plus optional name, unique, using (btree | hash | gist | spgist | gin | brin), a partial where clause, and concurrently for non-blocking creation.

Example: { "columns": ["email"], "unique": true, "using": "btree" }

Table-level constraints: a composite primaryKey (string[]), named unique constraints over multiple columns, and check constraints with arbitrary SQL expressions.