Content entries

Team members create content entries based on the content types that have been configured in a project. Entries represent structured content pieces (such as article, events, or products) that can be accessed by APIs for use in Canvas compositions or in any digital channel or application.

How entries differ#

An entry is structured content that represents a piece of content in a design-agnostic way. A component or composition describes the experience layer by defining which concrete UI component should be used to show particular content. Entries can also define relationships to other entries via references which allows to build complex content structures and reuse content.

By connecting the fields of an entry to the parameters of a component you define how the content is displayed in a certain context. For example, you could show the same article entry in a hero, a card, or a list component. Which fields of an entry are shown can be different for each use case.

Add or edit entry#

Access entries by going to Experience > Entries in the application navigation menu. If you click the Add an entry button, a list of available content types is shown.

Select an available content type to create your first entry.

Once you select a content type you will see the entry editor screen showing the fields available.

An example of an entry ready to be authored.

There are some fields that are common to all entries, and some that are dictated by how the content type is configured. Global elements include:

Name: A value extrapolated from the display name entered by the entry author.
Slug: Similar to name, this is a value extrapolated from the display name entered by the entry author.
Save: This will save the entry as a draft.
Publish: Clicking this will save and publish it.
A menu, accessed by , manages several properties:
- Manage data resources: Opens the data resource panel in the side rail.
- View source JSON data: Opens the source panel in the side rail.
- History: This opens the history panel in the side rail.
- View properties: Opens the properties panel in the side rail.
- Duplicate: This option creates an additional content entry with the same data as the original in a draft state. After selecting it, you will be taken to the duplicated entry.
- Edit content type: Selecting this will open the content type for additional configuration. Some roles may not have permission to edit content types.
- Delete entry: This will delete the entry.

There is also a side rail for quick access to functionality.

Side rail#

The side rail sits to the left of the screen and allows you to view details and resources connected to the current composition.

It contains five elements:

Element	Icon
Structure	The structure icon in the side rail
Data resources	The data resources icon in the side rail
Source	The source icon in the side rail
History	The history icon in the side rail
Properties	The properties icon in the side rail

Structure#

In the structure section shows the hierarchy of field groups and fields.

An example view of the structure element.

Data resources#

The data resources section provides features to manage your data sources and data types from within your entry.

An example view of the data resource element.

Unpublished content mode switch allows selecting content that, depending on data source configuration, hasn't been published yet, or that hasn't passed through normal workflow stages to become live, or belongs to a different environment.

info

Not all data sources support unpublished content mode. Check the documentation of your specific integration to see if this feature is available.

Source#

The source element shows you the references of your entry as JSON data. You can see entry data:

As it will be saved as JSON.
As it would be returned for use in a consuming application, with data resources applied.

An example view of the source element.

History#

Here you can see drafts and published versions of your entry. If you make several changes within the same day, those updates will be collected together as the number of versions created on the day. Selecting a revision will load the composition as "read only" with the references as they were at that point in time. You can:

See what was changed, when, and by whom.
Restore this version (which will create a new version with the associated references).
Go back to the current version.

By default, data is saved for the last 30 days. However, for projects on the Enterprise plan, data can be accessed for up to 365 days.

This is useful when there are multiple people collaborating on a single entry, or previous version data needs to be reviewed. You should note that this isn't a full audit feature. Uniform does track the references that are saved as JSON. It doesn't save the data coming from external sources. If you're reviewing a pattern, only the references will be saved.

An example view of the history element.

Properties#

Within the properties section of the structure panel you will see some basic information about your entry, including the:

Entry slug
Entry ID
Created, modified, modified by, content type, and last published dates. Clicking on the content type will open it for editing.

An example view of properties element.

Manage entries#

Once entries have been created, they're listed in the Experience > Entries section of the application.

For each entry the entry list you can click the icon to access a menu to perform the following actions:

Duplicate an entry
Unpublish an entry
Delete an entry

Unpublished content mode#

Content Entires support unpublished content mode. This mode allows content authors to see and use draft content in the visual editor before it was published.

This mode is disabled by default. To enable it:

Go to Experience > Data sources
Edit the Uniform Content data source
Check the Enable unpublished mode toggle

uniform-content-unpublished-content-toggle

Enabling unpublished content mode in the data source settings.

Searching, filtering, and sorting of entries#

You can search, filter and sort the entries list using a powerful set of granular filtering options.

These include:

Advanced full-text search on all supported field types of an entry (including typo tolerance)
Filter and sort by any system property (e.g. content type, publish status, enabled locales)
Filter and sort any entry metadata (e.g. creation date, modification date, author, name, slug)
Filter and sort by any custom field for entries of a selected content type

Filter entries using multiple filter conditions

info

For projects created before April 2024, need to enable the advanced search & filtering experience by following the steps in the Upgrading to advanced search and filtering experience section.

The basic search and filtering capabilities only support a basic set of filters and sorting options.

Supported field types#

The following field types are supported for search and filtering of custom fields in entries:

Field type	Search operators	Limitations
Text	`is` `is empty` `contains` `starts with` `is not` `is not empty`	none
Rich Text	`is empty` `contains` `starts with` `is not empty`	limited to for the first 10000 characters per Rich Text field
Number	`equals` `does not equal` `greater than` `greater than or equal to` `less than` `less than or equal to` `is empty` `is between` `is not empty`	none
Date	`is` `is between` `is before` `is after` `is on or before` `is on or after` `is empty` `is not` `is not empty`	none
Date/Time	`is` `is between` `is before` `is after` `is on or before` `is on or after` `is empty` `is not empty`	none
Single Select	`is` `is empty` `contains` `starts with` `is not` `is not empty`	none
Multi Select	`is` `is any of` `is empty` `is not` `is none of` `is not empty`	none
References	`is` `is any of` `is empty` `is not` `is none of` `is not empty`	Search and filter UI only support filtering by entry `id` of references API, SDK support filtering by system metadata such as `_slug` and `_name` No support for filtering by custom fields on referenced entries No support for nested references
Checkbox	`is checked` `is not checked`	none

Search and filtering on connected external data#

When entries or entry patterns are connected to external data sources using dynamic tokens, the search and filter capabilities can be applied to the connected data as well.

Uniform will only index the last resolved values that are used in the entry and will regularly update the values depending on the cache settings of the underlying data type for the data resource.

Known limitations for search and filtering#

These are the known limitations for search and filtering of entries. We are working on improving the search and filtering capabilities and will update this list as new features are added.

Filter and sort on custom fields limited to a single content type#
To be able to filter and sort on a custom field, it is required to specify a single content type in the filter conditions.
Filter entries by custom fields of a content type
note
It is not possible to filter or sort by custom fields across multiple content types at the same time, even if these content types share the same field settings.
Unsupported field types#
These field types are temporarily not supported for search and filtering:

Basic search and filtering experience#

Upgrade recommended

If your project was created before April 2024, we recommend upgrading to the advanced search & filtering experience.

This is a one-time and risk-free operation that will provide you with much improved and granular search, filter, and sort capabilities.

For older projects, the basic search and filtering experience provides the following options:

Filter by type: This will filter by the content types configured for your project
Sort by:
- Name (A-Z or Z-A)
- Modified date (ascending or descending)
- Created date (ascending or descending)
Filter the list by publishing status state: Published, Draft, Modified
Define how many results appear on each page (10, 20, 50, or 100)

Basic search and filtering experience for managing entries.

note

When a project only has the basic search and filtering experience enabled, then any advanced functionality is disabled also on the API and SDK level or when using data resources for entries.

Upgrading to advanced search and filtering experience#

For any Uniform project created before April 2024, the advanced search & filtering experience is not enabled by default. You can upgrade to it by following these steps:

Go to Settings > General to access the project settings.
On the top of the project settings page, you will see a callout to upgrade to the advanced search & filtering experience. Click the "Yes, ready to upgrade" button.
Confirm the modal window that gives you more information about the upgrade

Upgrade to the advanced search & filtering experience in the project settings

Upgrading is an optional but irreversible action. Once you upgrade, you cannot change back to the previous basic search & filtering experience. Upgrading does not require any downtime, code or configuration changes. Usually the upgrade only takes a few seconds to complete but if you have a large number of entries, it may take a few minutes.

You will notice that the upgrade is complete when you see the new search and filtering user interface in the Experience > Entries section.

Filter entries using multiple filter conditions

Use entries#

Use entries in compositions or component patterns#

To connect entries to compositions or component patterns, you need to create a data resources from a Uniform Content data type.

Not supported for entries

It is not possible to use data resources that are based on Uniform Content data types on entries, only compositions and component patterns are supported.

For each content type that has at least one entry, two data types are autogenerated, one for selecting a a single entry, and a second one for querying multiple entries of the same content type. These autogenerated data types have an Autogenerated pill in the listing of data types under Experience > Data types. Autogenerated data types can be modified like any other data type, but the Autogenerated pill will be removed once saved.

Autogenerated data types for a content type

Any number of additional data types can be created. Commonly these data types are limited to a single content type, but it is possible to create data types that can be used with multiple content types.

These archetypes are possible to create from Uniform Content data sources:

Single entry: allows you to select a single entry
Single entry by slug: allows you to select a single entry by its slug, useful when used with dynamic routes
Multiple entries: allows you to select multiple entries
Query entries: allows you to query entries based on a set of conditions

Make sure to publish your entries

To be able to use an entry in a data resource on a composition or component pattern, it needs to be published. If a published entry has been modified, it needs to be republished to reflect the changes in the data resource.

Available archetypes for Uniform Content data types

Selecting entries in data resources#

To make it easier to find the right entry to select you can use all search and filter capabilities. But once a selection has been made this search is not saved with the data resource.

Select a single entry in a data resource by using search and filter capabilities

Query entries in data resources#

Unlike the "Single entry" and "Multiple entries" archetypes, which allows content editor to make a static selection of a single or multiple entries, the "Query entries" archetype defines a search query that will return a "live" list of entries that match the query criteria.

This means when the query is configured on the data resource you see a preview of the current search result. The search result will change over time when entries that match the search criteria are added, changed or removed.

When you configure a "Query entries" data resource, you can use the same search and filter capabilities as you would when managing entries. This includes the ability to search by full-text, filter by system properties, custom fields, and sort the results.

Additionally, you can configure some additional query settings:

Search field: can be a static value or based on a dynamic input. This can be used to create search result pages where the search term is passed as a parameter in the URL.
Search filters: Also allows static values or dynamic inputs for system properties, entry metadata and custom fields of the selected content type.
Sort by: Allows you to sort the search results by a system property, entry metadata or custom field of the selected content type. Sort property and direction can be static values or dynamic inputs.
Show locale: Defines in which locale the entries should be returned. This is useful when you have entries with localized content and you want to show them in a specific language. If the project map has a "Locale" node defined, then the dynamic input for locale will be set as a default value(e.g. en-US).
Locale fallbacks for entries
It is also possible to specify a comma-separated list of locales to act as a fallback chain if the entry does not have translations in the specified locale. In this case the first matching locale on an entry will be returned. If no matching locale is found, the entry will not be included in the result set.
Under "Settings":
- Records to fetch: The maximum number of entries that will be returned by the query.
- Start from: Skip records and start at a specific index. This is useful for pagination.

Querying entries in a data resource

Use entries via API or SDK#

If entries should be consumed by a custom application or service, you can use Uniform APIs directly or using our SDK (ContentClient from @uniformdev/canvas) to retrieve entries.

Query entries via API#

Entries can be accessed via two different Uniform APIs:

Uniform Platform API: This API is used to manage and retrieve entries for management purposes. It does not support resolving "edgehanced" values in dynamic tokens.
The endpoint for entries can be found under /api/v1/entries.
Uniform Edge Delivery API: This API is used to retrieve entries for delivery purposes and runs on the CDN edge for optimal performance. It support resolving "edgehanced" values in dynamic tokens.
The endpoint for entries can be found under /api/v1/entries.

Query entries via Canvas SDK#

Example of fetching a list of "Recipe" entries using the Canvas SDK:

import { ContentClient, } from '@uniformdev/canvas'; const contentClient = new ContentClient({ apiKey: <canvasApiKey>, projectId: <projectId>, }); // example query to fetch 20 entries of "recipe" content type // with the search term "pizza" and order by modified date descending const recipes = await contentClient .getEntries({ filters: { type: { eq: 'recipe' }, }, search: 'pizza', limit: 20, orderBy: 'updated_at_DESC', }) .then(recipes => { return recipes.entries; });

On this page