emdash-cms/emdash

Features

• Content Management Systems - Manages structured content with custom collections, fields, and taxonomies through a visual admin interface and REST API.
• Plugin-Based Extensibility - Adds custom admin pages, dashboard widgets, and settings by reacting to content and media lifecycle events in native or sandboxed runtimes.
• Admin Panel Frameworks - Provides a built-in admin interface for editors to create, edit, and manage content without code.
• Scoped Stores - Separates each plugin's storage and KV operations by its slug for data isolation.
• Dashboard Entry Creators - Creates new content items with title, slug, rich text body, status, and taxonomy assignments through the admin dashboard.
• CMS - Creates and saves posts with a rich text editor, then displays them immediately on the public site.
• Schema-Backed Creations - Creates new content items as drafts or published entries, accepting field values matching the collection's schema.
• Menu Item Management - Provides an admin interface and API for creating, reordering, and nesting navigation menu items.
• Content Entry Retrievals - Retrieves one entry using its unique identifier or slug, returning the entry or a null result.
• Content Caching - Caches content queries, site settings, navigation menus, and taxonomy terms to speed up page renders.
• Content Schema Definitions - Creates, updates, deletes, and reorders collections and their fields to define the content structure.
• Custom Content Type Definitions - Creates structured content types with configurable slug, label, icon, and optional features.
• Visual Schema Definitions - Defines content types and fields visually or via seed files with immediate database migration and automatic TypeScript type generation.
• Content Modeling - Defines collections and fields through the admin UI or CLI with immediate changes and TypeScript generation.
• Translation Management - Retrieves all locale variants of a content item with translation group and version summaries.
• Content Scheduling Systems - Sets future publication dates for content and manages draft revisions before publication.
• File-Based Routing - Maps each file in the pages directory to a URL, mirroring the file tree as the route structure.
• Server-Rendered File Routings - Maps pages to files in the pages directory with server-side rendering that queries live content for instant updates.
• Type-Safe APIs - Provides a TypeScript API for querying and managing content with full type safety and autocomplete support.
• Drag-and-Drop Uploaders - Uploads files via drag-and-drop with signed URLs and organizes them in a visual media library.
• Multilingual Content Management - Manages translations as independent entries with per-locale slugs, status, and revision history.
• Partial Field Updates - Modifies existing content items by updating only the provided fields with optional conflict detection via a revision token.
• Per-Page Layout Overrides - Lets editors choose a visual layout per page from a dropdown and renders the matching component.
• Page Metadata Optimizations - Adds structured metadata like meta tags, OpenGraph properties, and JSON-LD to page headers.
• Rich Text Content Serialization - Captures and stores rich text in Portable Text format, supporting headings, lists, links, and images.
• Server-Side Content Delivery - Delivers content on each request in SSR mode for instant updates without rebuilding.
• Automated Migrations - Applies schema migrations automatically on first request for every supported database dialect.
• Content Query Filters - Fetches structured content entries with filters, limits, and taxonomy queries using typed function calls.
• Runtime Content Readers - Reads published content at runtime using collection and entry functions with filtering, pagination, and draft support.
• Query Result Caching - Caches content and configuration query results in a key/value store to reduce database read load.
• Seed File Content Model Definitions - Declares collections, fields, taxonomies, menus, and redirects in a JSON seed file that bootstraps the content schema on first run.
• Full Site Bootstraps - Defines collections, fields, taxonomies, menus, redirects, widget areas, settings, and sample content in a single JSON document to initialize a new site.
• Data Revision Tracking - Stores version snapshots of each content entry for review and restoration.
• Admin Field Type Abstractions - Defines structured content models using 16 field types, each mapped to a SQLite column with appropriate admin UI.
• Structured Content Type Managers - Defines and manages structured content types with custom fields through a visual admin interface.
• Schema Modification - Adds, renames, removes, or retypes fields on existing collections without losing stored content.
• Database Record Querying - Filters, sorts, and paginates records using indexed fields to retrieve matching items from a collection.
• Seed File Validators - Applies a JSON seed file during first-run setup to create collections, fields, menus, and sample content.
• Visual Front-End Editing - Annotates template elements with data attributes that allow authenticated editors to edit content directly on the page.
• Edge Cache Invalidation - Automatically clears cached entries when content is created, updated, published, or deleted.
• Multi-Backend Abstractions - Provides interchangeable content, media, and cache backends through a common interface supporting SQLite, PostgreSQL, D1, R2, and S3.
• Template-Level Content Queries - Fetches CMS collection entries directly in Astro templates with TypeScript types generated from the live database schema.
• Content Entry Fetches - Retrieves one content entry by its identifier and returns it for rendering in a template.
• CMS Content Fetching - Retrieves every entry for a given content type with error handling.
• TypeScript Type Generators - Generates TypeScript type definitions from the live content schema for type-safe queries.
• Content Schema Generators - Produces TypeScript types from the content schema for full type safety and autocomplete.
• Content Search Filters - Finds entries by title or body text and narrows results by status, date, author, or taxonomy.
• SQLite or PostgreSQL Storage - Connects to SQLite, D1, or PostgreSQL databases and local, R2, or S3-compatible storage for media.
• Multi-Database Support - Supports Cloudflare D1, libSQL, PostgreSQL, and SQLite databases, chosen at build time via configuration.
• Media Asset Managers - Provides a searchable, filterable media library with drag-and-drop upload, image preview, and bulk operations.
• Schema Field Additions - Adds new fields to content collection schemas with type, constraints, validation, and translatability settings.
• Type-Safe Query Builders - Generates TypeScript types from the content model for autocomplete and compile-time validation.
• Plugin Route Invocations - Lets the admin interface invoke plugin API routes using a hook that automatically attaches CSRF headers and the plugin prefix.
• Sandboxed Plugin Registrations - Registers sandboxed plugins in site configuration with optional runner selection for startup activation.
• User Installation Consents - Shows a consent dialog listing what data and system access a plugin requires before confirming installation.
• Server-Side Dynamic Page Generation - Queries CMS content at request time using server-rendered routes and displays it in dynamic page templates.
• Draft Content Publishing - Publishes a content item to make it live on the site, creating a published revision from the current draft.
• Admin API Invocations - Provides automatic plugin-id prefixing and CSRF header attachment when calling plugin routes from the admin interface.
• Plugin Descriptor Factories - EmDash exports a descriptor factory for build-time configuration and a createPlugin function for runtime behavior, both in one file.
• Plugin Data Stores - Persists plugin configuration and operational data in indexed collections and a per-plugin key-value store.
• Installation and Removal Event Handlers - Runs plugin code during installation, activation, deactivation, or removal of the plugin itself.
• Project Bootstrapping Templates - Scaffolds a full-stack CMS project from a starter template using a single command-line invocation.
• Scope Restrictions - Enforces fine-grained scopes on every tool call, limiting operations to content, media, or settings.
• Content Publication Schedulers - Sets a future publication date on a draft entry so it automatically becomes published at that time.
• Sandboxed Plugin Execution - Runs third-party plugins in isolated environments with declared capabilities, resource limits, and security audits.
• Plugin Definition APIs - Creates plugins using a definePlugin API with lifecycle hooks, storage, and admin pages, executed in isolated Cloudflare Workers.
• Administrative Site Settings - Reads and displays site-wide settings like title, logo, and tagline from the database.
• Site Structure Editors - Provides dedicated screens for navigation menus, widget areas, taxonomies, and site settings.
• API Route Handlers - Lets plugins define route handlers that receive a RouteContext and can query plugin storage or return data to the client.
• Node.js Runtimes - Runs the CMS on any Node.js 22+ host using the Astro Node adapter with SQLite or PostgreSQL.
• Database Admin UIs - Provides a WYSIWYG admin interface for creating and editing database-backed content.
• CMS and Frontend Bundles - Bundles the CMS admin interface and the Astro frontend site into a single codebase and deployment pipeline.
• Plugin Source Builds - Compiles plugin source into a distributable bundle containing hooks, routes, and a manifest for loading.
• Partial Site Settings Updates - Modifies one or more site-wide settings such as title, logo, SEO defaults, and social handles via partial update.
• Default Settings and Seed Data Initializers - Sets up default settings, storage collections, or seeds data when a plugin is first installed.
• Feature Extension Plugins - Adds feature extensions to the CMS by passing an array of plugin instances in the configuration.
• In-Process Plugin Runtimes - Runs plugin code in the same process as the site, granting full access to React admin pages and page HTML injection.
• Unified Plugin Definition Files - Declares a plugin with typed hooks, storage collections, and admin UI in a single definition file.
• Plugin Sandbox Runtimes - Selects and configures the isolated runtime for executing sandboxed plugins with declared capabilities and resource limits.
• Cloudflare Workers Deployments - Deploys the CMS onto Cloudflare's globally distributed edge runtime with D1 for database and R2 for media storage.
• Cloudflare Workers Deployments with D1 - Deploys the CMS on Cloudflare Workers with D1 for SQLite at the edge and R2 for S3-compatible storage.
• CMS Deployments - Deploys the CMS on Cloudflare Workers with D1 database and R2 storage for edge-based content management.
• Multi-Platform Deployments - Runs the CMS on Cloudflare Workers or a Node.js server with support for multiple SQL databases and S3-compatible storage.
• Media File Upload Handlers - Attaches images or files to content entries, storing metadata like dimensions, alt text, and file details.
• Content Lifecycle Hook Extensions - Modifies content before saving, filters queries, and injects head or footer markup through lifecycle hooks.
• Plugin Registrations - Adds native or sandboxed plugins directly in the Astro config file for build-time execution.
• Plugin Lifecycle Hooks - Responds to plugin activation, deactivation, and uninstallation events for setup and cleanup.
• Content CRUD Endpoints - Allows creating, reading, updating, and deleting content entries in any collection through standard HTTP endpoints.
• Authentication Providers - Replaces built-in passkey login with external providers like Cloudflare Access for authentication.
• Identity-Based Access Restrictions - Limits login to a configurable list of DIDs or handle patterns with wildcard support.
• Admin-Only Data Visibility - Shows only content and screens a user's role permits, with admin-only areas for schema and settings.
• OAuth 2.1 Implementations - Supports OAuth 2.1 Authorization Code with PKCE, Personal Access Tokens, and Device Flow.
• Passkey Authentication - Uses browser-based passkey authentication as the primary login method, eliminating passwords.
• Unified Passkey and OAuth Sign-in Flows - Supports passkeys, OAuth 2.1 flows, and external providers like Cloudflare Access with role-based access control.
• User Role Assignments - Assigns configurable roles to new users on first login, with the first user always becoming an Admin.
• Conditional Domain Role Restrictions - Assigns users to Administrator, Editor, Author, or Contributor roles and enforces permissions.
• Role & Permission Configurators - Requires a minimum RBAC role in addition to scopes, blocking operations when the role is too low.
• Security and Access Control - Implements passkey, OAuth, and external provider login with role-based permissions and fine-grained scopes.
• Route Authentication - Exposes HTTP endpoints under a plugin's namespace that require session or token authentication and enforce read and write permissions.
• Plugin Manifests - Declares a plugin's identity, trust contract, and registry profile in a hand-edited JSONC manifest file.
• Automatic Startup Migrations - Applies pending database migrations on the first request after deployment without manual intervention.
• Sandboxed Plugin Runtimes - Runs third-party code in an isolated runtime with declared capabilities and resource limits, installable from a marketplace.
• Middleware Lifecycle Hooks - Registers callbacks that run at defined points in the request lifecycle, allowing custom logic to modify behavior.
• Content Lifecycle - Runs plugin code when content is created, updated, or deleted, receiving event data and plugin context.
• Federated - Discovers and installs plugins from a federated registry with signed releases, capability review, and integrity verification.
• Plugin Context Access - Provides hooks with a context object containing storage, HTTP, logging, and other plugin APIs.
• Hook-Based Plugin Systems - Fires hooks before and after content operations, letting plugins modify data or trigger side effects without altering core logic.
• Storage Abstractions - Provides a consistent storage API so switching between backends requires no code changes.
• Content Taxonomies - Organizes content entries into hierarchical categories and flat tags for structured retrieval.
• CMS Project Scaffolds - Creates a new Astro project from a theme template, then runs a setup wizard that applies a seed file to bootstrap collections, menus, and sample content.
• Admin Dashboard Frameworks - Renders React components on the admin dashboard in configurable sizes for at-a-glance information.
• React-Based Admin Interfaces - Lets developers render custom admin pages and dashboard widgets using React components registered in the plugin definition.
• Plugin-Registered Pages - Lets plugins add custom pages and dashboard widgets under their own namespace without overriding core screens.
• Custom Page Mounts - Lets plugins mount React components as custom admin pages with sidebar navigation and icon support.
• Admin Panel Extensions - Lets plugins contribute pages and dashboard widgets to the admin interface with auto-generated settings forms.
• Single Item Retrievals - Retrieves a single content item by ID or slug with all field values, metadata, and a revision token for conflict detection.
• Signed Preview Links - Creates HMAC-signed, time-limited URLs for sharing draft content with reviewers without authentication.
• Single Content Previews - Fetches a single content entry by its slug and displays its fields, including rich text and images.
• Token-Based Draft Previews - Serves unpublished draft entries automatically when a valid preview token is present in the request URL.
• Structured Block Renderers - Transforms rich text blocks into HTML using configurable component mappings.
• Custom Navigation Menus - Builds editable navigation menus with custom links, internal page references, and external URLs.
• Rich Text Editors - Formats text with headings, lists, links, images, code blocks, embeds, and reusable sections using a WYSIWYG editor.
• Filtered Paginated Listings - Returns paginated content items from a collection with optional filtering by status, locale, and sort order.
• Live Preview Renderers - Updates rendered content instantly as editors make changes without a manual rebuild or redeploy.
• Server-Fetched Menu Structures - Loads menu structures with nested items for building site navigation and dropdowns from a backend API.
• Remote Menu Retrievals - Retrieves a full menu by name with nested items and locale resolution from a CMS.
• Navigation Menu Management - Provides an API to return navigation menus, optionally filtered by locale.
• Page Layout Templates - Maps a select field on pages to different layout components, letting editors choose a page layout.
• Paginated Content Collection Displays - Retrieves and renders content collection entries filtered by status and sorted by date.
• Portable Text Renderers - Stores structured rich text as Portable Text JSON, enabling flexible rendering with custom block components and cross-format conversion.
• Custom Block Type Rendering - Ships a custom block type system for structured content rendered via a component map.
• Editors - Provides a rich text editor using Portable Text format for structured content editing with custom block types.
• Runtime Content Update Streaming - Reflects content changes instantly without a rebuild by streaming updates at runtime.
• Drafting Workflows - Provides a draft/published state for content entries with preview and scheduling capabilities.
• Plugin-Defined Endpoints - Registers custom HTTP endpoints under a scoped path that return JSON responses from plugin logic.
• CMS Plugin Development - Provides a framework for building and distributing plugins with lifecycle hooks, admin UI components, and sandboxed execution.
• Frontend Inline Editors - Lets users edit page content directly on the live site with a visual editor and save without leaving the frontend.
• Plugin Systems - Provides an extensible plugin system for Astro with native and sandboxed plugins, lifecycle hooks, and admin UI.
• Global Site Configuration - Stores and retrieves site-wide configuration values such as title, tagline, logo, and social links.
• Locale Fallback Mechanisms - Retrieves entries filtered by locale with automatic fallback to a configured locale when content is missing.
• Content Translation - Creates linked translations of any content entry for configured locales with independent management.
• Plugin Capability Consents - Shows a consent dialog listing all declared capabilities when installing a plugin.
• Rich Text Editors - Offers a formatted rich text editor with support for headings, lists, quotes, code, links, and embedded media.
• SEO Metadata Injection - Automatically inserts meta tags, Open Graph properties, and JSON-LD into page headers.
• Plugin Definitions - Ships a single-file plugin definition format that separates runtime code from identity metadata.
• Recurring Task Scheduling - Executes handler functions when scheduled cron jobs fire, enabling periodic background work.
• Decentralized Plugin Registry Browsers - Browses, searches, and installs sandboxed plugins from a decentralized registry.
• Menu Assistants - Lets AI assistants view, create, and manage navigation menus via natural language.
• Site Settings Assistants - Enables AI assistants to inspect and update site identity, SEO defaults, social links, and logo/favicon through natural language.
• Taxonomy Assistants - Lets AI assistants browse, create, rename, and delete taxonomy terms via natural language.
• CMS Assistants - Connects an MCP server for natural language content management via AI.
• Search Assistants - Enables AI assistants to search across all content collections via natural language.
• Media Library Assistants - Lets AI assistants browse, register, update, and delete media items via natural language.
• Collection Listings - Lists all content collections defined in the CMS, returning slug, label, supported features, and timestamps.
• Plugin Data Storage - Uses indexed storage within the plugin to persist structured data and query it with ordering and limits.
• Field Validation - Enforces per-field rules such as character limits, numeric ranges, regex patterns, and required values.
• Content Block CRUD APIs - Allows creating, reading, updating, and deleting content blocks through standard HTTP endpoints for external tooling.
• Soft Deletions - Soft-deletes content items by moving them to a trash state for later restoration or permanent removal.
• User Invitation Management - Sends a time-limited invitation link to a specified email address, allowing the recipient to register with a passkey.
• Post Taxonomy Term Lists - Renders assigned categories and tags as links or labels on content pages.
• Term-Based Content Filters - Queries collection entries that are assigned a specific category or tag term from a taxonomy.
• Author Profiles - Defines author or contributor identities separate from user accounts for attribution across content.
• Custom Block Type Definitions - Declares custom block types for the Portable Text editor with form fields and display labels.
• CLI Content Managers - Lists, reads, creates, updates, deletes, publishes, and schedules content entries through remote API calls.
• Admin-Defined Menu Queries - Fetches navigation menus configured in the CMS and renders them in layouts without hard-coded links.
• Collection-Based Content Searches - Performs full-text search across content collections with per-field searchability configuration.
• Format Conversions - Transforms content between Portable Text and ProseMirror formats for storage and editing.
• RSS Feed Generation - Produces an XML feed of published entries with title, date, description, and link for syndication.
• Section-Based Layout Management - Creates, reads, updates, and deletes page sections for structuring content layouts.
• Section Retrieval by Identifier - Fetches paginated content sections with filtering by source, search, or slug for layout components.
• Cache Backend Configurations - Supports multiple cache backends including Cloudflare KV and in-process memory, configurable through integration settings.
• Collection Schemas - Returns detailed information about a collection including all field definitions, types, constraints, and validation rules.
• Cross-Collection Search Engines - Runs global full-text search across multiple content collections with highlighted snippets.
• Plugin - Accesses declared storage collections at runtime to persist and retrieve operational data like submissions or logs.
• Schema Exports - Exports the content schema as JSON or TypeScript interfaces for use in external tooling.
• Content and Schema Seed Exports - Dumps the database schema and all content into a single JSON file for versioning or bootstrapping other instances.
• WordPress Content Migrations - Imports WordPress WXR exports, mapping posts, pages, media, taxonomies, and custom fields.
• Astro CMS Importers - Imports WordPress content, including posts, pages, media, and taxonomies, into an Astro-based CMS.
• Batch Insert, Update, or Delete Operations - Reads, writes, or deletes multiple records in a single call to reduce round trips and improve throughput.
• Schema Compatibility Validators - Parses incoming content and compares its structure against existing collections for compatibility.
• CLI Schema Management - Lets users list, inspect, create, and delete collections and fields from the command line.
• Automatic System Fields - Automatically assigns stable identifiers, status, timestamps, and versioning to every content entry.
• Database Seeding via Import - Reads a seed file from a configurable path and applies it when the database is empty, falling back to a built-in default.
• Full Text Search - Indexes content with FTS5 full-text search and returns relevant results across all collections.
• Cursor-Based Pagination - Returns cursor-based paginated lists from storage queries, matching the platform's standard pagination shape.
• Read Replica Routing Preferences - Directs read queries to nearby read replicas to reduce latency for visitors far from the primary database region.
• Configurable Storage Backends - Stores uploaded files on local disk, Cloudflare R2, or any S3-compatible service via a single integration.
• Local Filesystem Storage - Stores uploaded media files in a local directory on disk, suitable for development environments.
• Plugin Configuration Stores - Stores plugin configuration in a private key-value store scoped to each plugin, accessible from any hook or route.
• Collection Typed Wrappers - Casts storage collections to typed interfaces for editor IntelliSense and compile-time checks.
• Custom Collection Interfaces - Creates typed storage collections with indexes and queries them via a structured API.
• API Error Handling - Lets developers throw errors to return generic error responses that mask internal details, or throw a Response for a specific status code.
• Plugin Bundling for Distribution - Packages the built plugin with optional assets into a registry-ready tarball, validating contents before output.
• Media Management CLI Tools - Lists, uploads, retrieves, and deletes media files with optional metadata like alt text and captions.
• Bulk Operations - Selects multiple entries and publishes, archives, or deletes them in a single action.
• Taxonomy Page Generators - Generates static pages for each taxonomy term, listing associated entries with full routing support.
• Plugin Interaction Handling - Processes page loads, button clicks, and form submissions from the admin UI through a request-response cycle.
• AI-Assisted Reviews - Lets AI assistants view revision history and restore content versions via natural language.
• Setup Wizards - Walks through initial site title, tagline, admin email, and passkey registration in the admin panel.
• Static Route Generators - Generates static routes at build time by fetching published entries and mapping them to URL parameters.
• S3-Compatible Storage Adapters - Stores uploaded media files in any S3-compatible service, including Cloudflare R2 and MinIO.
• Plugin Packaging - Declares build scripts, exports, and peer dependencies in package.json so a plugin can be installed and consumed by the CMS.
• Plugin Build and Validation - Schema-checks the manifest and compiles the plugin into deployable artifacts using a CLI command.
• Example Entry Seeders - Populates collections with example entries, including references to other content and media assets.
• Cloudflare R2 Object Storages - Stores uploaded media files using Cloudflare R2 bindings for fast integration with Workers deployments.
• Plugin Distribution Packages - Packages sandboxed plugin source into tarballs after building and validating for distribution.
• Plugin Publishing - Registers a new version of a plugin by pointing the registry at a publicly hosted tarball, enforcing publisher identity and license requirements.
• Content Import Source Interfaces - Implements a source interface to import content from platforms not covered by built-in importers.
• HTTP Payment Gating - Requires a payment before serving premium content, returning a 402 response when unpaid.
• Plugin Management Endpoints - Lists, retrieves, enables, and disables installed plugins through the REST API.
• Indexed Collection Declarations - Defines named collections with indexed and unique-indexed fields that the plugin uses for persistent data.
• Custom Login Provider Development - Provides a framework for developers to implement custom authentication methods with React components and route handlers.
• Download Integrity Verification - Checksums downloaded plugin artifacts and confirms their identity before activation.
• Signed URL Uploads - Uploads files directly to storage via time-limited signed URLs, keeping large payloads off the application server.
• Input Validation Schemas - Parses and validates request bodies or query strings against a Zod schema, returning a 400 error for invalid data.
• Discovery Endpoint Exposures - Publishes OAuth 2.1 metadata documents at well-known URLs for automatic client discovery.
• Registry Authentication Managers - Signs in and manages publisher sessions for the plugin registry, supporting multiple accounts and session switching.
• Secret Encryption - Protects sensitive plugin configuration by encrypting it with a user-provided key never stored in the database.
• Security Audit Plugins - Runs automated security scans on each plugin version and displays the verdict with a detailed report.
• Social Login Providers - Integrates third-party authentication services like GitHub or Google through a common provider interface.
• Token Signature Verification - Validates incoming preview requests by checking the HMAC-SHA256 signature and expiration of the embedded token.
• External User Provisioning - Automatically creates user accounts from an external identity provider's group memberships, mapping groups to internal roles.
• API Error Handling Patterns - Catches typed error classes for database, validation, storage, and schema failures.
• Offline Manifest Validation - Checks plugin configuration files against their schema offline, reporting cross-field errors with file and line references.
• Plugin Storage Declarations - Defines typed collections in the manifest so the plugin can persist and query structured data at runtime.
• Default Configuration Values - Provides fallback values at read time or persists defaults during plugin installation to ensure sensible initial values.
• Plugin Scaffolds - Generates a complete plugin project with manifest, source, tests, and configuration from a single slug input.
• Marketplace Plugin Installers - Browses, installs, and manages plugins through an admin dashboard with one-click updates.
• Plugin Publishing - Submits a sandboxed plugin through a bundling and security audit process for distribution and installation within the CMS.
• Event Reactions - Triggers custom code on content saves, media uploads, comment moderation, and plugin lifecycle events.
• Plugin Registries - Points the admin dashboard at a federated plugin registry for browsing and installing sandboxed plugins.
• Registry Search - Queries the registry for available plugins and retrieves detailed package information, with machine-readable output option.
• REST Term Managers - Creates, reads, updates, and deletes taxonomy terms and their assignments through REST endpoints.
• Term Retrieval Queries - Retrieves all terms for a taxonomy, returning a tree for hierarchical types or a flat list for flat types.
• Term-Based Content Filters - Filters content entries by assigned taxonomy terms for targeted retrieval.
• Post-Scaffolding Customizations - Lets users edit generated Astro pages, layouts, and content models after scaffolding.
• Plugin Invocation Limiters - Enforces CPU, subrequest, wall-clock, and memory limits per plugin invocation.
• Schema Management Assistants - Allows admin users to inspect, create, and modify content collection schemas through natural language commands.
• Admin UI Customization - Declares admin pages and dashboard widgets that a plugin renders via Block Kit in the management interface.
• JSON-Based Admin UI Building - Describes a plugin's admin interface as JSON blocks that the host renders, keeping plugin JavaScript out of the browser.
• Schema-Driven Settings Forms - Generates auto-built settings forms from a schema with field types like string, number, boolean, select, and secret.
• Admin Section Editors - Provides a graphical interface to create, edit, search, filter, and delete content blocks with previews.
• Reusable Section Registries - Defines pre-built content blocks that editors insert into Portable Text fields via a slash command.
• Schema-Driven Settings Pages - Creates a settings page from a schema definition without writing custom React components.
• Custom HTML Embeds - Embeds custom markup, third-party widgets, or markup imported from other systems inside a content entry.
• Reusable Content Blocks - Inserts pre-built content blocks into documents via a slash command for reusable patterns.
• Dashboard Widget Components - Renders registered components with configurable props as dashboard widgets within the admin interface.
• Content Entry References - Links content entries together via single or multiple references to other collections, stored as entry IDs.
• Admin Field Display Configurations - Adjusts admin UI behavior per field, including textarea rows, image previews, and display order.
• JSON Block Layout Forms - Describes the settings page as a JSON block layout served from a plugin route, handling save interactions automatically.
• Optimized Image Renderers - Renders image fields with an Image component supporting lazy loading and fetch priority hints.
• Rendering Overrides - Allows user-provided Astro components to override plugin defaults when rendering block types.
• Reusable UI Components - Defines self-contained components with typed props and slots for consistent reuse across templates.
• Admin Interface Components - Provides ready-made UI components like Card, Button, Input, Select, Toggle, Table, and Alert for admin interfaces.
• API Widget Area Managers - Creates widget areas and adds content or component widgets through admin API endpoints.
• Scoped Style Generators - Wraps CSS rules with unique class names to isolate styles to individual components.
• Key-Value Settings Storage - Reads and writes plugin configuration through a key-value store, conventionally under a settings prefix.
• Portable Text Renderers - Displays rich text content stored as Portable Text using a dedicated rendering component.
• Collection Creators - Creates new content collections with a slug, label, and optional features like drafts, revisions, and scheduling.
• External Plugin Route Invocations - Allows invoking plugin API routes from outside the admin UI by sending standard HTTP requests with session or token authentication.
• Page Content Injections - Inserts scripts or HTML into page templates at specified placements for analytics or custom code.
• Direct-to-Cloud Uploads - Generates signed upload URLs so clients can upload large files directly to S3-compatible storage without passing through the server.
• Extension Registry Configurations - Points a site at an aggregator URL and optionally accepts labels from specific labellers to control plugin discovery.
• Conditional Field Visibility - Reveals or hides input fields based on the value of another field, evaluated client-side without a server round-trip.
• Form Input Collection - Presents text, number, select, toggle, and masked input fields with conditional visibility and submit handling.
• Admin Translation Interfaces - Creates new translations pre-filled from the source locale with per-locale publishing and independent slugs.
• API Translation Creation - Creates a translation by passing locale and translationOf parameters, sharing the source entry's translation group and starting as a draft.
• Translatability Controls - Marks fields as translatable for per-locale editing or non-translatable to keep values synced across translations.
• Starter Templates - Bootstraps new sites using blog, marketing, or portfolio templates with pre-built layouts and features.
• On-Demand Component Loading - Defers loading JavaScript components until trigger events like viewport entry or browser idle.
• JSON Response Formatters - Wraps any JSON-serializable return value in a standard success envelope and serves it as application/json.
• Redirection Rules - Maps legacy or moved URLs to new destinations to preserve links after migration.

Star history