Renick.Content

Block-based content editing for OctoberCMS 4.3. A content document is a list of typed blocks (heading, rich text, image, button, section, and more) stored as JSON in a host field, edited with a backend block editor, and rendered on the frontend through a fallback-safe renderer.

Official landing page: https://www.renick.io/de/content-plugin

Install

The plugin registers itself through the standard OctoberCMS discovery. With the plugin in plugins/renick/content:

php artisan october:migrate      # boots the plugin
php artisan plugin:list          # shows: Renick.Content

Usage

Tailor entries

Add a contenteditor field to a blueprint:

fields:
    content:
        label: Content
        type: contenteditor

The field stores the document JSON in a longText column and renders the block editor in the entry form.

Backend forms

The same widget is available to any backend form as type: contenteditor.

Frontend rendering

Render a stored document on a CMS page with the component:

[renickContent]
==
{% component 'renickContent' document=post.content %}

…or inline with the Twig function anywhere in a theme:

{{ content_render(post.content)|raw }}

Both funnel through BlockRenderer, which resolves each block's partial theme override → plugin default → safe placeholder and never throws on a missing or unknown block (D10): the offending block degrades to an HTML comment (plus a visible card in debug) while its neighbours still render.

Blocks

Every block also carries generic settings (spacing top/bottom, width, CSS class, anchor id — rendered as rc-* utility classes) and visibility (on/off toggle, show-from / show-until schedule, evaluated server-side at render time). The document format is published as JSON Schema in schema/document-v1.json.

Each block is a YAML definition plus a default partial in blocks/<handle>/. A theme may override a partial at partials/renick-content/<handle>.htm; the default guarantees rendering never breaks.

Layout

classes/        BlockDefinition, ContentDocument, VisibilityRules, BlockManager, BlockRenderer,
                StaticPagesIntegration, RainLabBlogIntegration
blocks/         block definitions (YAML) + default partials
console/        Artisan commands (export/import bundle, prune versions/proxy cache, reindex media, seed demo)
formwidgets/    ContentEditor form widget (mount partial; UI ships in assets/dist)
contentfields/  ContentEditor Tailor content field
components/     Content component (renickContent)
assets/src/     Editor source — TypeScript + React 18 + TipTap 3 (see INITIAL_PLAN.md#25-the-editor)
assets/dist/    COMMITTED editor bundle (single ESM file + css)
tests/unit/     PHPUnit suite

Editor build

The backend editor is a TipTap 3 / React island bundled with Vite (pnpm). Consumers never build anything — assets/dist is committed and shipped.

cd plugins/renick/content
pnpm install
pnpm run typecheck && pnpm test   # TS + Vitest (converter round-trips, fuzz, constraints)
pnpm run build                    # rebuild assets/dist (CI fails if stale)

AI & REST API

AI features are disabled by default. Configure them under Settings → Renick Content AI: provider (OpenAI, OpenRouter, or the offline mock driver for testing), API keys (encrypted at rest), per-feature models, an image-generation model and storage target, a monthly token budget (warn-only) and the Firecrawl research toggle.

In the editor toolbar the AI menu offers Translate… (values only — structure, ids and URLs stay untouched), Draft from brief… and Research & draft… (Firecrawl-gathered sources; requires the privacy toggle); the image block can generate images from a prompt. Every AI result shows a block-diff confirmation modal before it is applied, and records an auditable ai_translate / ai_draft version.

Custom Scripts (JS bound to a placeholder block) can be AI-generated behind a review gate: generated code is loaded into the form for the admin to review and only becomes public once they save it, with create/update logging and a created_by/updated_by audit trail.

The REST API is off by default. Enable it plus a bearer token in the AI settings; endpoints live under /api/renick/content/v1:

GET  /document?host_type=&host_id=&field=   # document + media manifest
PUT  /document                              # write (normalize + validate)
GET  /document/bundle?host_type=&host_id=&field=  # export document + media as a ZIP
POST /document/bundle                       # import a ZIP bundle
POST /translate                             # {host…, target_language}
POST /draft                                 # {brief, template_id?}
POST /duplicate                             # {document} → re-id'd copy
GET  /templates
GET  /versions?host_type=&host_id=&field=
POST /restore                               # {host…, version_id}

All requests: Authorization: Bearer <token>. Writes snapshot the previous state first and record the action in the audit log. The same service classes back the editor (Renick\Content\Classes\Content facade for PHP consumers).

The group is rate-limited (default 60 requests/minute, keyed by token then client IP) and enforces body-size caps (2 MB for a document, 50 MB for a bundle → HTTP 413 on overflow). All limits are overridable via env or config/renick/content/limits.php — see config/limits.php.

Plugin integrations

Two opt-in integrations let the block editor take over content fields in other plugins, configured under Settings → Content Editor → Integrations. Each switch is inert unless the matching plugin is installed, and neither is a hard dependency:

• RainLab.Pages — edit a static page's content with the block editor. The swap happens only for pages whose markup is empty or already a block document; existing HTML pages keep the rich editor untouched.
• RainLab.Blog — edit a blog post's content with the block editor. Same rule: only empty or already-block posts switch; existing Markdown posts are untouched. The rendered content_html is generated from the block document on save, so the stock RainLab blog components keep working.

Command line

Artisan commands (run from the October install root):

php artisan renick:content:export-bundle --host=… --id=… [--field=content] [--out=file.zip] [--dry-run]
php artisan renick:content:import-bundle --host=… --id=… --in=file.zip [--overwrite-media] [--force] [--dry-run]
php artisan renick:content:prune-versions [--days=180]   # delete unpinned versions older than N days
php artisan renick:content:prune-proxy-cache             # clear expired map-tile / video-thumbnail cache
php artisan renick:content:reindex-media                 # rebuild the media usage index
php artisan renick:content:seed-demo [--section=Content\\Article]  # demo entry with every block

Both bundle commands accept --dry-run to print exactly what they would read/write without touching the filesystem or the database.

License

Renick.Content is proprietary, commercial software — source-available, not open source. Being able to view the source code does not grant a right to use it. Any production use requires a valid, paid license per installation / per site, purchased from the Licensor. Local, non-production evaluation is permitted.

The block-based content format (its specification and schema) is separately licensed under MIT, so authored content stays portable and interoperable. The plugin implementation itself remains proprietary.

See LICENSE.md for the full terms. Copyright © 2026 Renick Büttner. Licensing enquiries: complains@renick.io.