includio-cms 0.7.1 → 0.13.0

package/CHANGELOG.md

@@ -3,6 +3,123 @@
 All notable changes to includio-cms are documented here.
 Generated from `src/lib/updates/` — do not edit manually.
 
+## 0.13.0 — 2026-03-19
+
+Private file uploads for form submissions
+
+### Added
+- Private file uploads — form submissions can upload files to a non-public directory with access control
+
+## 0.12.0 — 2026-03-18
+
+File field type, dataOrderBy, and _url population
+
+### Added
+- File field type with multipart upload, file validation, and rate limiting
+- `dataOrderBy` — sort entries by JSON data fields in queries
+- Auto-populate `_url` field on entries from slug resolver and `pathTemplate`
+
+## 0.11.0 — 2026-03-18
+
+Codegen overhaul and REST API consolidation
+
+### Added
+- Codegen: flat entry types, inline block types, `countEntries` query helper, simplified API surface
+- REST API: catch-all route handler, file upload endpoint, media endpoint, schema template endpoints
+- Admin scaffold updated for new REST route structure
+
+## 0.10.0 — 2026-03-18
+
+Remove image, video, richtext field types — consolidate to media and content
+
+### Breaking
+- Removed `image` field type — use `media` with `accept: "image/*"` instead
+- Removed `richtext` field type — use `content` (structured ProseMirror JSON) instead
+- Removed `ImageField` and `RichtextField` TypeScript interfaces
+- `image-field.svelte` and `richtext-field.svelte` components removed
+- `tiptap.svelte` (HTML richtext wrapper) removed
+
+### Notes
+
+No automatic data migration. Replace `type: "image"` with `type: "media", accept: "image/*"` in your collection/singleton configs. Replace `type: "richtext"` with `type: "content"`. Existing stored data (media UUIDs, ProseMirror docs) remains compatible.
+
+## 0.9.0 — 2026-03-17
+
+Per-language entry versions — separate entry_version per language
+
+### Added
+- Per-language entry versions: each language gets its own entry_version with flat data
+- Per-language publication: publish/unpublish each language independently
+- Simplified data format: no more nested `{ pl: "X", en: "Y" }` — values are flat strings
+- Language switching in admin loads different version data
+
+### Breaking
+- `entry_version` table: new `lang` column (NOT NULL)
+- `entry` table: removed `published_at`, `published_version_id`, `published_by`, `available_locales` columns
+- `RawEntry`: `publishedVersion`/`draftVersion`/`scheduledVersion` replaced with per-lang `publishedVersions`/`draftVersions`/`scheduledVersions` records
+- `DbEntryVersion`/`DbEntryVersionInsert`: new required `lang` field
+- `translateObject` removed — data is single-language per version
+- Resolve functions (relation, media, url, richtext) expect flat content/richtext values, not `Record<lang, value>`
+- `upsertDraftVersion` and `pruneOldDraftVersions` now require `lang` parameter
+- `unpublishEntry` renamed to `unpublishEntryLang` with required `lang` parameter
+
+### Migration
+
+```sql
+-- Step 1: Add lang column as nullable
+ALTER TABLE entry_version ADD COLUMN lang TEXT;
+
+-- Step 2: Run migration script to split multi-lang versions (scripts/migrate-lang-versions.ts)
+-- After migration, set NOT NULL:
+ALTER TABLE entry_version ALTER COLUMN lang SET NOT NULL;
+
+-- Step 3: Create index for performance
+CREATE INDEX idx_entry_version_publish ON entry_version(entry_id, lang, published_at);
+
+-- Step 4: Remove entry-level publish columns
+ALTER TABLE entry DROP COLUMN IF EXISTS published_at;
+ALTER TABLE entry DROP COLUMN IF EXISTS published_version_id;
+ALTER TABLE entry DROP COLUMN IF EXISTS published_by;
+ALTER TABLE entry DROP COLUMN IF EXISTS available_locales;
+```
+
+### Notes
+
+Run the migration script BEFORE setting lang to NOT NULL. See scripts/migrate-lang-versions.ts for data migration.
+
+## 0.8.0 — 2026-03-17
+
+Flat entry format — remove data wrapper from objects/blocks
+
+### Added
+- Flat entry format: objects use `_slug` + spread fields instead of `slug` + `data` wrapper
+- Blocks use `_slug` instead of `slug` with flat fields
+- Entry type unified: `FlatEntry` renamed to `Entry`, old `Entry` removed
+
+### Breaking
+- Object field data format: `{ slug, data: {...} }` → `{ _slug, ...fields }`
+- Blocks field data format: `{ _id, slug, data: {...} }` → `{ _id, _slug, ...fields }`
+- `FlatEntry` type removed — use `Entry` instead
+- `flattenEntry`/`flattenFields` removed — data is flat from resolve functions
+
+### Notes
+
+Run `includio update` to migrate existing entry data in the database.
+
+## 0.7.3 — 2026-03-17
+
+Typography orphan fix for Polish conjunctions
+
+### Added
+- Read-time orphan fix — replace space after single-letter Polish conjunctions (i, w, z, o, u, a) with non-breaking space `\u00A0`
+
+## 0.7.2 — 2026-03-16
+
+CLI create-user command
+
+### Added
+- CLI `create-user` command — interactive user creation with email, password (auto-generate option), name, and role via better-auth
+
 ## 0.7.1 — 2026-03-13
 
 Custom fields plugin system, pathTemplate, admin public API

package/ROADMAP.md

@@ -163,14 +163,56 @@
 - [x] `[feature]` `[P2]` resolveMediaWithStyles utility & core svelte export
 - [x] `[fix]` `[P1]` Schema serialization type cast (stricter TS compatibility)
 
-## 0.8.0 — SEO module
+## 0.7.2 — CLI create-user
+
+- [x] `[feature]` `[P1]` CLI `create-user` command — interactive user creation with role assignment <!-- files: src/lib/cli/create-user.ts, src/lib/cli/index.ts -->
+
+## 0.7.3 — Typography
+
+- [x] `[feature]` `[P1]` Read-time orphan fix — replace space after single-letter Polish conjunctions with `\u00A0` <!-- files: src/lib/core/server/fields/resolveTypographyOrphans.ts, src/lib/core/server/fields/utils/fixOrphans.ts -->
+
+## 0.8.0 — Flat entry format
+
+- [x] `[breaking]` `[P0]` Flat entry format: objects use `_slug` + spread fields instead of `slug` + `data` wrapper
+- [x] `[breaking]` `[P0]` Blocks use `_slug` instead of `slug` with flat fields
+- [x] `[breaking]` `[P0]` `FlatEntry` type removed — use `Entry` instead
+
+## 0.9.0 — Per-language entry versions
+
+- [x] `[breaking]` `[P0]` Per-language entry versions: each language gets its own `entry_version` with flat data
+- [x] `[feature]` `[P0]` Per-language publication: publish/unpublish each language independently
+- [x] `[breaking]` `[P0]` Simplified data format: no more nested `{ pl: "X", en: "Y" }` — values are flat strings
+
+## 0.10.0 — Field type consolidation
+
+- [x] `[breaking]` `[P1]` Remove `image` field type — use `media` with `accept: "image/*"`
+- [x] `[breaking]` `[P1]` Remove `richtext` field type — use `content` (structured JSON)
+- [x] `[chore]` `[P1]` Remove `ImageField`, `RichtextField` interfaces + components
+
+## 0.11.0 — Codegen & REST consolidation
+
+- [x] `[feature]` `[P1]` Codegen: flat types, inline block types, `countEntries`, simplified API
+- [x] `[feature]` `[P1]` REST API: catch-all route, upload endpoint, media endpoint, schema templates
+- [x] `[chore]` `[P1]` Admin scaffold updated for new REST route structure
+
+## 0.12.0 — File field, dataOrderBy, _url
+
+- [x] `[feature]` `[P1]` File field type with multipart upload, validation, rate limiting
+- [x] `[feature]` `[P1]` `dataOrderBy` — sort entries by JSON data fields
+- [x] `[feature]` `[P1]` Auto-populate `_url` field on entries from slug resolver
+
+## 0.13.0 — Private file uploads
+
+- [x] `[feature]` `[P1]` Private file uploads — form submissions can upload files to non-public directory
+
+## 0.14.0 — SEO module
 
 - [ ] `[feature]` `[P1]` SERP preview + character limits for title/description <!-- files: src/lib/admin/components/fields/seo-field.svelte -->
 - [ ] `[feature]` `[P1]` Global SEO settings
 - [ ] `[feature]` `[P1]` Dedicated frontend SEO components <!-- files: src/lib/sveltekit/components/seo.svelte -->
 - [ ] `[feature]` `[P2]` Sitemap generation
 
-## 0.9.0 — WCAG/ATAG compliance
+## 0.15.0 — WCAG/ATAG compliance
 
 - [ ] `[chore]` `[P0]` Full WCAG/ATAG audit
 - [ ] `[feature]` `[P0]` Accessibility rework based on audit findings

package/dist/admin/api/generate-styles.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from '@sveltejs/kit';
+export declare const POST: RequestHandler;

package/dist/admin/api/generate-styles.js

@@ -0,0 +1,32 @@
+import { requireRole } from '../remote/middleware/auth.js';
+import { batchGenerateAllStyles } from '../../core/server/media/styles/operations/batchGenerateStyles.js';
+export const POST = async () => {
+    requireRole('admin');
+    const abort = new AbortController();
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of batchGenerateAllStyles(abort.signal)) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }
+            }
+            catch (e) {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', error: e instanceof Error ? e.message : String(e) })}\n\n`));
+            }
+            finally {
+                controller.close();
+            }
+        },
+        cancel() {
+            abort.abort();
+        }
+    });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+        }
+    });
+};

package/dist/admin/api/handler.js

@@ -5,6 +5,10 @@ import * as replaceHandlers from './replace.js';
 import * as inviteHandlers from './invite.js';
 import * as acceptInviteHandlers from './accept-invite.js';
 import * as mediaGcHandlers from './media-gc.js';
+import * as generateStylesHandlers from './generate-styles.js';
+import { requireAuth } from '../remote/middleware/auth.js';
+import { getCMS } from '../../core/cms.js';
+import { lookup } from 'mrmime';
 export function createAdminApiHandler(options) {
     const routes = {
         upload: uploadHandlers,
@@ -13,14 +17,43 @@ export function createAdminApiHandler(options) {
         invite: inviteHandlers,
         'accept-invite': acceptInviteHandlers,
         'media-gc': mediaGcHandlers,
+        'generate-styles': generateStylesHandlers,
         ...options?.extraRoutes
     };
+    const privateMediaGet = async (event) => {
+        requireAuth();
+        const path = event.params.path;
+        const filename = path.replace('media/private/', '');
+        if (!filename || filename.includes('/') || filename.includes('..')) {
+            return json({ error: 'Invalid filename' }, { status: 400 });
+        }
+        const adapter = getCMS().filesAdapter;
+        if (!adapter.downloadPrivateFile) {
+            return json({ error: 'Not supported' }, { status: 501 });
+        }
+        const file = await adapter.downloadPrivateFile(filename);
+        if (!file) {
+            return json({ error: 'Not found' }, { status: 404 });
+        }
+        const contentType = lookup(filename) || 'application/octet-stream';
+        return new Response(await file.arrayBuffer(), {
+            headers: {
+                'Content-Type': contentType,
+                'Content-Disposition': `inline; filename="${filename}"`,
+                'Cache-Control': 'private, no-store'
+            }
+        });
+    };
     function handle(method) {
         return (event) => {
             const path = event.params.path;
             if (!path) {
                 return json({ error: 'Not found' }, { status: 404 });
             }
+            // Handle media/private/[filename] route
+            if (path.startsWith('media/private/') && method === 'GET') {
+                return privateMediaGet(event);
+            }
             const handler = routes[path]?.[method];
             if (!handler) {
                 return json({ error: 'Not found' }, { status: 404 });

package/dist/admin/api/media-gc.js

@@ -1,13 +1,19 @@
 import { requireRole } from '../remote/middleware/auth.js';
-import { getImageStylesStats, purgeAllImageStyles } from '../../core/server/media/operations/purgeImageStyles.js';
+import { purgeAllImageStyles } from '../../core/server/media/operations/purgeImageStyles.js';
 import { getReconciliationReport, deleteOrphanedDiskFiles } from '../../core/server/media/operations/reconcileMedia.js';
+import { getStylesStatus } from '../../core/server/media/styles/operations/batchGenerateStyles.js';
 import { json } from '@sveltejs/kit';
 export const GET = async ({ url }) => {
     requireRole('admin');
-    const stats = await getImageStylesStats();
-    const report = await getReconciliationReport();
+    const [stylesStatus, report] = await Promise.all([
+        getStylesStatus(),
+        getReconciliationReport()
+    ]);
     return json({
-        imageStylesCount: stats.count,
+        imageStylesCount: stylesStatus.existingStyles,
+        processableImagesCount: stylesStatus.processableImages,
+        expectedStylesCount: stylesStatus.expectedStyles,
+        missingStylesCount: stylesStatus.missingStyles,
         orphanedDiskFiles: report.orphanedDisk,
         missingDiskRecords: report.missingDisk
     });

package/dist/admin/api/rest/handler.js

@@ -5,6 +5,8 @@ import * as languagesRoutes from './routes/languages.js';
 import * as collectionsRoutes from './routes/collections.js';
 import * as singletonsRoutes from './routes/singletons.js';
 import * as entriesRoutes from './routes/entries.js';
+import * as uploadRoutes from './routes/upload.js';
+import * as mediaRoutes from './routes/media.js';
 function matchRoute(method, path) {
     // Schema routes
     if (method === 'GET' && path === 'schema') {
@@ -17,6 +19,15 @@ function matchRoute(method, path) {
     if (method === 'GET' && path === 'languages') {
         return { handler: 'languages', params: [] };
     }
+    // Upload: POST /upload
+    if (method === 'POST' && path === 'upload') {
+        return { handler: 'upload', params: [] };
+    }
+    // Media: GET /media/:id
+    const mediaMatch = path.match(/^media\/([^/]+)$/);
+    if (method === 'GET' && mediaMatch) {
+        return { handler: 'media', params: [mediaMatch[1]] };
+    }
     // Entries lifecycle: POST /entries/:id/:action
     const entriesMatch = path.match(/^entries\/([^/]+)\/(publish|unpublish|archive|unarchive)$/);
     if (method === 'POST' && entriesMatch) {
@@ -53,6 +64,12 @@ export function createRestApiHandler() {
             }
             try {
                 switch (route.handler) {
+                    case 'upload':
+                        return await uploadRoutes.POST(event);
+                    case 'media': {
+                        const [mediaId] = route.params;
+                        return await mediaRoutes.GET(event, mediaId);
+                    }
                     case 'schema': {
                         // Pass restPath minus 'schema/' prefix
                         const schemaPath = restPath === 'schema' ? '' : restPath.slice(7);

package/dist/admin/api/rest/routes/collections.js

@@ -2,13 +2,14 @@ import { json } from '@sveltejs/kit';
 import { getCMS } from '../../../../core/cms.js';
 import { getRawEntries, getRawEntry, countRawEntries } from '../../../../core/server/entries/operations/get.js';
 import { createEntry } from '../../../../core/server/entries/operations/create.js';
-import { upsertDraftVersion } from '../../../../core/server/entries/operations/update.js';
+import { upsertDraftVersion, updateEntry, updateEntryVersion } from '../../../../core/server/entries/operations/update.js';
 import { deleteEntry } from '../../../../core/server/entries/operations/delete.js';
 export async function GET(event, slug, id) {
     const cms = getCMS();
     if (!cms.collections[slug]) {
         return json({ error: `Collection "${slug}" not found` }, { status: 404 });
     }
+    const lang = event.url.searchParams.get('lang') || cms.languages[0] || 'en';
     // GET /collections/:slug/:id — single entry
     if (id) {
         const entry = await getRawEntry({ id, slug, includeArchived: true });
@@ -21,14 +22,12 @@ export async function GET(event, slug, id) {
             type: entry.type,
             createdAt: entry.createdAt,
             updatedAt: entry.updatedAt,
-            publishedAt: entry.publishedAt,
             archivedAt: entry.archivedAt,
-            availableLocales: entry.availableLocales,
             sortOrder: entry.sortOrder,
-            draftData: entry.draftVersion?.data ?? null,
-            publishedData: entry.publishedVersion?.data ?? null,
-            draftVersionId: entry.draftVersion?.id ?? null,
-            publishedVersionId: entry.publishedVersion?.id ?? null
+            draftData: entry.draftVersions[lang]?.data ?? null,
+            publishedData: entry.publishedVersions[lang]?.data ?? null,
+            draftVersionId: entry.draftVersions[lang]?.id ?? null,
+            publishedVersionId: entry.publishedVersions[lang]?.id ?? null
         });
     }
     // GET /collections/:slug — list
@@ -48,12 +47,10 @@ export async function GET(event, slug, id) {
         type: entry.type,
         createdAt: entry.createdAt,
         updatedAt: entry.updatedAt,
-        publishedAt: entry.publishedAt,
         archivedAt: entry.archivedAt,
-        availableLocales: entry.availableLocales,
         sortOrder: entry.sortOrder,
-        draftData: entry.draftVersion?.data ?? null,
-        publishedData: entry.publishedVersion?.data ?? null
+        draftData: entry.draftVersions[lang]?.data ?? null,
+        publishedData: entry.publishedVersions[lang]?.data ?? null
     }));
     return json({ items, total, limit, offset });
 }
@@ -62,11 +59,25 @@ export async function POST(event, slug) {
     if (!cms.collections[slug]) {
         return json({ error: `Collection "${slug}" not found` }, { status: 404 });
     }
+    const lang = event.url.searchParams.get('lang') || cms.languages[0] || 'en';
     const body = await event.request.json().catch(() => null);
     const entry = await createEntry({ slug, type: 'collection' });
     // If data provided, save as draft
     if (body?.data && typeof body.data === 'object') {
-        await upsertDraftVersion(entry.id, body.data, { skipValidation: true });
+        await upsertDraftVersion(entry.id, body.data, lang, { skipValidation: true });
+    }
+    // Auto-publish if requested
+    if (body?.publish) {
+        const raw = await getRawEntry({ id: entry.id, slug });
+        const draftVersion = raw?.draftVersions[lang];
+        if (draftVersion) {
+            const user = event.locals.user;
+            await updateEntryVersion(draftVersion.id, {
+                publishedAt: new Date(),
+                publishedBy: user?.id ?? 'api'
+            });
+        }
+        return json({ id: entry.id, slug: entry.slug, published: true }, { status: 201 });
     }
     return json({ id: entry.id, slug: entry.slug }, { status: 201 });
 }
@@ -79,11 +90,12 @@ export async function PUT(event, slug, id) {
     if (!entry) {
         return json({ error: 'Entry not found' }, { status: 404 });
     }
+    const lang = event.url.searchParams.get('lang') || cms.languages[0] || 'en';
     const body = await event.request.json().catch(() => null);
     if (!body?.data || typeof body.data !== 'object') {
         return json({ error: 'Request body must contain "data" object' }, { status: 400 });
     }
-    const version = await upsertDraftVersion(entry.id, body.data, { skipValidation: true });
+    const version = await upsertDraftVersion(entry.id, body.data, lang, { skipValidation: true });
     return json({
         id: entry.id,
         versionId: version.id,

package/dist/admin/api/rest/routes/entries.d.ts

@@ -1,2 +1,2 @@
 import { type RequestEvent } from '@sveltejs/kit';
-export declare function POST(_event: RequestEvent, id: string, action: string): Promise<Response>;
+export declare function POST(event: RequestEvent, id: string, action: string): Promise<Response>;

package/dist/admin/api/rest/routes/entries.js

@@ -1,26 +1,26 @@
 import { json } from '@sveltejs/kit';
-import { requireAuth } from '../../../remote/middleware/auth.js';
+import { getCMS } from '../../../../core/cms.js';
 import { getRawEntryOrThrow } from '../../../../core/server/entries/operations/get.js';
-import { updateEntry, unpublishEntry } from '../../../../core/server/entries/operations/update.js';
-export async function POST(_event, id, action) {
-    const { user } = requireAuth();
+import { updateEntry, updateEntryVersion, unpublishEntryLang } from '../../../../core/server/entries/operations/update.js';
+export async function POST(event, id, action) {
+    const user = event.locals.user;
+    const lang = event.url.searchParams.get('lang') || getCMS().languages[0] || 'en';
     switch (action) {
         case 'publish': {
             const entry = await getRawEntryOrThrow({ id, includeArchived: false });
-            const draftVersion = entry.draftVersion;
+            const draftVersion = entry.draftVersions[lang];
             if (!draftVersion) {
                 return json({ error: 'No draft version to publish' }, { status: 400 });
             }
-            await updateEntry(id, {
-                publishedVersionId: draftVersion.id,
+            await updateEntryVersion(draftVersion.id, {
                 publishedAt: new Date(),
-                publishedBy: user.id,
-                archivedAt: null
+                publishedBy: user.id
             });
+            await updateEntry(id, { archivedAt: null });
             return json({ success: true, publishedVersionId: draftVersion.id });
         }
         case 'unpublish': {
-            await unpublishEntry(id);
+            await unpublishEntryLang(id, lang);
             return json({ success: true });
         }
         case 'archive': {

package/dist/admin/api/rest/routes/media.d.ts

@@ -0,0 +1,2 @@
+import { type RequestEvent } from '@sveltejs/kit';
+export declare function GET(_event: RequestEvent, id: string): Promise<Response>;

package/dist/admin/api/rest/routes/media.js

@@ -0,0 +1,9 @@
+import { json } from '@sveltejs/kit';
+import { getFile } from '../../../../core/server/media/operations/getFiles.js';
+export async function GET(_event, id) {
+    const file = await getFile(id);
+    if (!file) {
+        return json({ error: 'Media file not found' }, { status: 404 });
+    }
+    return json(file);
+}

package/dist/admin/api/rest/routes/schema.d.ts

@@ -1,2 +1,7 @@
 import { type RequestEvent } from '@sveltejs/kit';
+import type { Field } from '../../../../types/fields.js';
+export declare function generateTemplate(fields: Field[], languages: string[]): {
+    template: Record<string, unknown>;
+    meta: Record<string, string>;
+};
 export declare function GET(event: RequestEvent): Promise<Response>;

package/dist/admin/api/rest/routes/schema.js

@@ -10,9 +10,161 @@ function serializeField(field) {
 function serializeFields(fields) {
     return fields.map(serializeField);
 }
+function localize(value, languages) {
+    const obj = {};
+    for (const lang of languages) {
+        obj[lang] = value;
+    }
+    return obj;
+}
+function generateFieldTemplate(field, languages) {
+    const wrap = (v, hint) => {
+        if (field.localized) {
+            return { value: localize(v, languages), hint: `${hint} (localized)` };
+        }
+        return { value: v, hint };
+    };
+    switch (field.type) {
+        case 'text':
+        case 'slug':
+            return wrap('', 'string');
+        case 'content':
+            return wrap({ type: 'doc', content: [] }, 'ProseMirror JSON document');
+        case 'number':
+            return wrap(0, 'number');
+        case 'boolean':
+            return { value: false, hint: 'boolean' };
+        case 'date':
+            return wrap('2024-01-01', 'ISO date string');
+        case 'datetime':
+            return wrap('2024-01-01T00:00:00Z', 'ISO datetime string');
+        case 'file':
+            if (field.multiple) {
+                return { value: ['<media-uuid-from-upload>'], hint: 'array of media UUIDs from POST /upload' };
+            }
+            return { value: '<media-uuid-from-upload>', hint: 'media UUID from POST /upload' };
+        case 'media':
+            if (field.multiple) {
+                return { value: ['<media-uuid-from-upload>'], hint: 'array of media UUIDs (image or video)' };
+            }
+            return { value: '<media-uuid-from-upload>', hint: 'media UUID (image or video) from POST /upload' };
+        case 'select': {
+            const sf = field;
+            const opts = sf.options.map((o) => o.value);
+            if (sf.multiple) {
+                return { value: opts.length ? [opts[0]] : [], hint: `array of: ${opts.join(' | ')}` };
+            }
+            return { value: opts[0] ?? '', hint: `one of: ${opts.join(' | ')}` };
+        }
+        case 'radio': {
+            const rf = field;
+            const opts = rf.options.map((o) => o.value);
+            return { value: opts[0] ?? '', hint: `one of: ${opts.join(' | ')}` };
+        }
+        case 'checkboxes': {
+            const cf = field;
+            const opts = cf.options.map((o) => o.value);
+            return { value: opts.length ? [opts[0]] : [], hint: `array of: ${opts.join(' | ')}` };
+        }
+        case 'relation': {
+            const rf = field;
+            if (rf.multiple) {
+                return { value: ['<entry-uuid>'], hint: `array of ${rf.collection} entry UUIDs` };
+            }
+            return { value: '<entry-uuid>', hint: `${rf.collection} entry UUID` };
+        }
+        case 'object': {
+            const of = field;
+            const { template, meta } = generateTemplate(of.fields, languages);
+            return { value: template, hint: `object — ${JSON.stringify(meta)}` };
+        }
+        case 'blocks': {
+            const bf = field;
+            const blocks = bf.of.map((block) => {
+                const { template } = generateTemplate(block.fields, languages);
+                return { _slug: block.slug, ...template };
+            });
+            return { value: blocks, hint: 'array of block objects with _slug' };
+        }
+        case 'array': {
+            const af = field;
+            const examples = { text: '', number: 0, url: { url: { [languages[0]]: '' } } };
+            return { value: [examples[af.of] ?? ''], hint: `array of ${af.of}` };
+        }
+        case 'seo':
+            return {
+                value: {
+                    slug: localize('', languages),
+                    title: localize('', languages),
+                    description: localize('', languages),
+                    ogImage: '',
+                    keywords: localize('', languages),
+                    canonicalUrl: localize('', languages),
+                    customCode: localize('', languages)
+                },
+                hint: 'SEO data — slug/title required, ogImage = media UUID or empty'
+            };
+        case 'url':
+            return {
+                value: {
+                    url: localize('', languages),
+                    text: localize('', languages),
+                    newTab: false
+                },
+                hint: 'URL field with optional text and newTab'
+            };
+        case 'custom':
+            return { value: null, hint: 'custom field — check plugin docs' };
+        default:
+            return { value: null, hint: 'unknown field type' };
+    }
+}
+export function generateTemplate(fields, languages) {
+    const template = {};
+    const meta = {};
+    for (const field of fields) {
+        const { value, hint } = generateFieldTemplate(field, languages);
+        template[field.slug] = value;
+        meta[field.slug] = hint;
+    }
+    return { template, meta };
+}
 export async function GET(event) {
     const cms = getCMS();
     const path = event.params.restPath || '';
+    // GET /schema/collections/:slug/template
+    const templateMatch = path.match(/^collections\/([^/]+)\/template$/);
+    if (templateMatch) {
+        const slug = templateMatch[1];
+        const collection = cms.collections[slug];
+        if (!collection) {
+            return json({ error: `Collection "${slug}" not found` }, { status: 404 });
+        }
+        const fields = getFieldsFromConfig(collection);
+        const { template, meta } = generateTemplate(fields, cms.languages);
+        return json({
+            data: template,
+            publish: true,
+            _meta: meta,
+            _notes: 'POST this to /collections/' + slug + ' — set publish:true to auto-publish'
+        });
+    }
+    // GET /schema/singletons/:slug/template
+    const singletonTemplateMatch = path.match(/^singletons\/([^/]+)\/template$/);
+    if (singletonTemplateMatch) {
+        const slug = singletonTemplateMatch[1];
+        const single = cms.singles[slug];
+        if (!single) {
+            return json({ error: `Singleton "${slug}" not found` }, { status: 404 });
+        }
+        const fields = getFieldsFromConfig(single);
+        const { template, meta } = generateTemplate(fields, cms.languages);
+        return json({
+            data: template,
+            _meta: meta,
+            _notes: 'PUT this to /singletons/' + slug
+        });
+    }
     // GET /schema/collections/:slug
     const collectionMatch = path.match(/^collections\/([^/]+)$/);
     if (collectionMatch) {

package/dist/admin/api/rest/routes/singletons.d.ts

@@ -1,3 +1,3 @@
 import { type RequestEvent } from '@sveltejs/kit';
-export declare function GET(_event: RequestEvent, slug: string): Promise<Response>;
+export declare function GET(event: RequestEvent, slug: string): Promise<Response>;
 export declare function PUT(event: RequestEvent, slug: string): Promise<Response>;