Collections are structured data sets defined by a schema. Think of them like database tables but stored as JSON files (or MongoDB documents in Pro mode). Each collection has a name, a URL slug, and a list of typed fields that define the shape of every entry.

Collections power the content layer of Domma CMS. Once defined, each collection automatically gets an admin UI for managing entries and a REST API for reading and writing data.

Common use cases

Each collection is defined in the admin panel with a name, slug, storage adapter, and a list of fields. The schema is stored as a JSON file in data/schemas/{slug}.schema.json and can be version-controlled alongside your project.

Below is the full schema for a typical Blog Posts collection. Each field specifies its name, type, and optional constraints such as required or default.

{
  "name": "Blog Posts",
  "slug": "posts",
  "adapter": "file",
  "fields": [
    { "name": "title",       "type": "string",   "required": true },
    { "name": "content",     "type": "richtext"                   },
    { "name": "published",   "type": "boolean",  "default": false },
    { "name": "publishedAt", "type": "date"                       },
    { "name": "tags",        "type": "tags"                       },
    { "name": "image",       "type": "media"                      }
  ]
}

Domma CMS supports 16 built-in field types covering text, media, relational, and specialised inputs. Every field type renders an appropriate input in the admin entry editor and applies the correct validation and serialisation.

New collections are created through the admin panel. Once saved, the collection is immediately available via the REST API and appears in the admin navigation under Collections.

Steps to create a collection

1. Navigate to Admin panel → Collections → New Collection
2. Enter a human-readable Name (e.g. Blog Posts)
3. The Slug is auto-generated from the name (e.g. posts) — edit if needed
4. Choose a Storage adapter: file (default) or mongo (Pro)
5. Click Add Field to define each field — set its name, type, and constraints
6. Reorder fields by dragging the row handle
7. Click Save Collection — the schema is written to data/schemas/{slug}.schema.json

Import & export schemas

Collections can be exported as JSON schema files and re-imported into any Domma CMS instance. This is useful for sharing schemas between projects or seeding a fresh installation.

# Export a schema from the CLI
npx domma cms schema:export posts

# Import a schema file
npx domma cms schema:import ./posts.schema.json

Every collection gets a full Create, Read, Update, Delete interface in the admin panel and a matching REST API. Both surfaces are generated automatically from the field schema — no additional configuration is needed.

GET    /api/collections/{slug}/entries
POST   /api/collections/{slug}/entries
GET    /api/collections/{slug}/entries/{id}
PUT    /api/collections/{slug}/entries/{id}
DELETE /api/collections/{slug}/entries/{id}

Example: create an entry via the API

const response = await H.post('/api/collections/posts/entries', {
    title:       'Hello World',
    content:     '<p>My first post.</p>',
    published:   true,
    publishedAt: '2026-03-13',
    tags:        ['intro', 'news']
});

E.toast('Post created', { type: 'success' });

Domma CMS supports two storage adapters. The default FileAdapter requires zero configuration and is ideal for small-to-medium collections. The MongoAdapter (Pro) unlocks unlimited scale and advanced query capabilities.

Switching adapters

To switch an existing collection to MongoDB, update the adapter field in the schema and run the migration command. Pro mode must be active.

// In data/schemas/posts.schema.json — change:
{ "adapter": "file" }

// To:
{ "adapter": "mongo" }

# Migrate existing JSON data into MongoDB
npx domma cms migrate:adapter posts --from=file --to=mongo

Domma CMS ships with 8 optional preset collections. These cover the most common content modelling patterns and can be seeded into a fresh installation with a single command — complete with schemas and sample data.

npm run seed

Collection entries can be exported to CSV or JSON and re-imported at any time. This is useful for data migrations, backups, bulk edits in a spreadsheet, or seeding a staging environment from production data.

Format requirements

title,published,tags
"Hello World",true,"intro,news"
"Second Post",false,""

[
  {
    "title": "Hello World",
    "published": true,
    "tags": ["intro", "news"]
  },
  {
    "title": "Second Post",
    "published": false,
    "tags": []
  }
]

Collection entries can be embedded directly in Markdown pages using the [collection] shortcode. The shortcode fetches entries at build time (or at request time in server-rendered mode) and renders them using the collection's configured block template.

[collection slug="posts" limit="5" orderBy="publishedAt" order="desc"]
[collection slug="team" template="card"]
[collection slug="products" filter="published:true" limit="12"]

Shortcode attributes

By default all collection API endpoints require a valid JWT bearer token. Collections marked public: true in their schema are also accessible via a separate unauthenticated public API — useful for reading content in front-end applications without exposing credentials.

GET /api/public/collections/{slug}/entries
GET /api/public/collections/{slug}/entries/{id}

GET    /api/collections/{slug}/entries
POST   /api/collections/{slug}/entries
PUT    /api/collections/{slug}/entries/{id}
DELETE /api/collections/{slug}/entries/{id}

Example: fetch public posts with Domma HTTP

// Read public collection — no auth needed
const { entries } = await H.get('/api/public/collections/posts/entries', {
    params: { limit: 5, orderBy: 'publishedAt', order: 'desc' }
});

T.create('#posts-table', {
    data: entries,
    columns: [
        { key: 'title',       label: 'Title'      },
        { key: 'publishedAt', label: 'Published'  },
        { key: 'tags',        label: 'Tags'       }
    ]
});

Enabling public access on a collection

// In data/schemas/posts.schema.json — add:
{
  "name":    "Blog Posts",
  "slug":    "posts",
  "adapter": "file",
  "public":  true,
  "fields":  [ ... ]
}