includio-cms 0.5.7 → 0.6.1

package/dist/core/fields/layoutUtils.js

@@ -5,7 +5,8 @@ export function getFieldsFromConfig(config) {
 export function hasLayout(config) {
     return !!config.layout;
 }
-/** Collect all field slugs referenced in layout nodes (depth-first order) */
+/** Collect all field paths referenced in layout nodes (depth-first order).
+ *  Supports both plain slugs ('title') and dot-notation ('hero.title'). */
 export function collectFieldSlugs(nodes) {
     const slugs = [];
     for (const node of nodes) {
@@ -18,28 +19,133 @@ export function collectFieldSlugs(nodes) {
     }
     return slugs;
 }
+/**
+ * Resolve a field definition by dot-notation path.
+ * E.g. 'companyInfo.contact.email' navigates: fields → companyInfo → fields → contact → fields → email
+ */
+export function resolveFieldByPath(fields, path) {
+    const parts = path.split('.');
+    let current = fields;
+    for (let i = 0; i < parts.length; i++) {
+        const field = current.find((f) => f.slug === parts[i]);
+        if (!field)
+            return undefined;
+        if (i === parts.length - 1)
+            return field;
+        if (field.type !== 'object' || !('fields' in field))
+            return undefined;
+        current = field.fields;
+    }
+    return undefined;
+}
+/**
+ * Collect all leaf field paths from field definitions (recursively flattens objects).
+ * E.g. an object 'hero' with fields 'title','image' → ['hero.title', 'hero.image']
+ * Non-object fields at top level → ['slug']
+ */
+export function collectAllLeafPaths(fields, prefix = '') {
+    const paths = [];
+    for (const f of fields) {
+        const fullPath = prefix ? `${prefix}.${f.slug}` : f.slug;
+        if (f.type === 'object' && 'fields' in f) {
+            paths.push(...collectAllLeafPaths(f.fields, fullPath));
+        }
+        else {
+            paths.push(fullPath);
+        }
+    }
+    return paths;
+}
+/**
+ * Expand a layout field reference into leaf paths.
+ * - 'title' (non-object) → ['title']
+ * - 'hero' (object with fields) → ['hero.title', 'hero.image', ...]
+ * - 'hero.title' (dot-notation to leaf) → ['hero.title']
+ */
+function expandToLeafPaths(ref, fields) {
+    const resolved = resolveFieldByPath(fields, ref);
+    if (!resolved)
+        return [ref]; // unresolved — let validation catch it
+    if (resolved.type === 'object' && 'fields' in resolved) {
+        return collectAllLeafPaths(resolved.fields, ref);
+    }
+    return [ref];
+}
+/**
+ * Identify top-level object slugs where ALL leaf fields are individually
+ * distributed across layout nodes (via dot-notation).
+ * These objects should suppress their own wrapper rendering.
+ */
+export function getDistributedObjectSlugs(nodes, fields) {
+    const refs = collectFieldSlugs(nodes);
+    const distributed = new Set();
+    for (const f of fields) {
+        if (f.type !== 'object' || !('fields' in f))
+            continue;
+        // Check: is this object referenced as a whole?
+        if (refs.includes(f.slug))
+            continue;
+        // Get all leaf paths for this object
+        const leafPaths = collectAllLeafPaths(f.fields, f.slug);
+        if (leafPaths.length === 0)
+            continue;
+        // Check if ALL leaf paths are covered by layout refs
+        const allCovered = leafPaths.every((lp) => refs.includes(lp));
+        if (allCovered)
+            distributed.add(f.slug);
+    }
+    return distributed;
+}
+/**
+ * Build SuperForm-compatible path for a dot-notation field reference.
+ * 'hero.title' → 'hero.data.title'
+ * 'hero.contact.email' → 'hero.data.contact.data.email'
+ * 'title' → 'title' (no change for top-level)
+ */
+export function buildFormPath(dotPath) {
+    const parts = dotPath.split('.');
+    if (parts.length <= 1)
+        return dotPath;
+    const result = [parts[0]];
+    for (let i = 1; i < parts.length; i++) {
+        result.push('data', parts[i]);
+    }
+    return result.join('.');
+}
 /** Count columns expected by a ratio string */
 function columnCount(ratio) {
     return ratio.split(' ').length;
 }
-/** Validate layout against fields — returns errors or empty array */
+/** Validate layout against fields — returns errors or empty array.
+ *  Supports dot-notation paths (e.g. 'hero.title'). */
 export function validateLayout(nodes, fields) {
     const errors = [];
-    const fieldSlugs = new Set(fields.map((f) => f.slug));
+    const topLevelSlugs = new Set(fields.map((f) => f.slug));
     const referencedSlugs = collectFieldSlugs(nodes);
-    // Check for missing fields
+    // Check for missing fields — support both top-level slugs and dot-notation
     for (const slug of referencedSlugs) {
-        if (!fieldSlugs.has(slug)) {
-            errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+        if (slug.includes('.')) {
+            // Dot-notation: resolve through field tree
+            if (!resolveFieldByPath(fields, slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
+        }
+        else {
+            if (!topLevelSlugs.has(slug)) {
+                errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+            }
         }
     }
-    // Check for duplicates
-    const seen = new Set();
-    for (const slug of referencedSlugs) {
-        if (seen.has(slug)) {
-            errors.push({ type: 'duplicate_field', message: `Field "${slug}" referenced multiple times` });
+    // Check for duplicates (expand to leaf paths for overlap detection)
+    const seenLeaves = new Set();
+    for (const ref of referencedSlugs) {
+        const leaves = expandToLeafPaths(ref, fields);
+        for (const leaf of leaves) {
+            if (seenLeaves.has(leaf)) {
+                errors.push({ type: 'duplicate_field', message: `Field "${leaf}" referenced multiple times` });
+            }
+            seenLeaves.add(leaf);
         }
-        seen.add(slug);
     }
     // Check depth + columns
     function walk(nodeList, depth) {
@@ -72,7 +178,8 @@ export function resolveLayout(layout, fields) {
         return layout;
     return expandPreset(layout, fields);
 }
-/** Resolve layout + append orphan fields in a trailing section */
+/** Resolve layout + append orphan fields in a trailing section.
+ *  Orphan detection works at leaf level — dot-notation refs count as covering their leaves. */
 export function resolveLayoutWithOrphans(config) {
     if (!config.layout) {
         // No layout — single section with all fields
@@ -85,16 +192,37 @@ export function resolveLayoutWithOrphans(config) {
         ];
     }
     const nodes = resolveLayout(config.layout, config.fields);
-    const referenced = new Set(collectFieldSlugs(nodes));
-    const orphans = config.fields.filter((f) => !referenced.has(f.slug)).map((f) => f.slug);
-    if (orphans.length === 0)
+    const refs = collectFieldSlugs(nodes);
+    // Expand all refs to leaf paths for coverage checking
+    const coveredLeaves = new Set();
+    for (const ref of refs) {
+        for (const leaf of expandToLeafPaths(ref, config.fields)) {
+            coveredLeaves.add(leaf);
+        }
+    }
+    // Find orphan top-level fields (not covered at all)
+    const allLeaves = collectAllLeafPaths(config.fields);
+    const orphanTopSlugs = [];
+    for (const f of config.fields) {
+        if (f.type === 'object' && 'fields' in f) {
+            const objectLeaves = collectAllLeafPaths(f.fields, f.slug);
+            const anyCovered = objectLeaves.some((lp) => coveredLeaves.has(lp));
+            if (!anyCovered)
+                orphanTopSlugs.push(f.slug);
+        }
+        else {
+            if (!coveredLeaves.has(f.slug))
+                orphanTopSlugs.push(f.slug);
+        }
+    }
+    if (orphanTopSlugs.length === 0)
         return nodes;
     return [
         ...nodes,
         {
             type: 'section',
             label: { en: 'Other', pl: 'Pozostałe' },
-            fields: orphans
+            fields: orphanTopSlugs
         }
     ];
 }

package/dist/core/server/generator/generator.js

@@ -31,7 +31,8 @@ function generateTypesStringForRecords(type, records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -58,7 +59,8 @@ function generateTypesStringForForms(records) {
 		export type ${recordTypeString}EntryMap = {
 			${records
         .map((single) => {
-        return `${single.slug}: ${toPascalCase(single.slug)}`;
+        const key = single.slug.includes('-') ? `'${single.slug}'` : single.slug;
+        return `${key}: ${toPascalCase(single.slug)}`;
     })
         .join(';\n')}
 		}
@@ -94,10 +96,10 @@ function generateAPI(config) {
 	`;
     code += `
 
-		interface GetEntryQueryOptions<T extends { data: Record<string, unknown> }> {
+		interface GetEntryQueryOptions {
 			id?: string;
 			status?: 'draft' | 'published' | 'scheduled' | 'archived';
-			dataValues?: Partial<T['data']>;
+			dataValues?: Record<string, unknown>;
 		}
 
 		interface GetEntryOptions {
@@ -118,7 +120,7 @@ function generateAPI(config) {
 		`;
     code += `
 
-		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions<SingleEntryMap[K]>, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
+		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -126,7 +128,7 @@ function generateAPI(config) {
 			})) as unknown as SingleEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions<CollectionEntryMap[K]>, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
+		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
 			return (await getEntry({
 			  ...data,
 				slug,
@@ -134,7 +136,15 @@ function generateAPI(config) {
 			})) as unknown as CollectionEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions): Promise<CollectionEntryMap[K][]> {
+		interface GetEntriesQueryOptions {
+			ids?: string[];
+			status?: 'draft' | 'published' | 'scheduled' | 'archived';
+			dataValues?: Record<string, unknown>;
+			dataLike?: Record<string, unknown>;
+			orderBy?: { column: 'createdAt' | 'updatedAt' | 'sortOrder'; direction: 'asc' | 'desc' };
+		}
+
+		export async function getCollectionEntries<K extends CollectionSlug>(slug: K, options: GetEntryOptions & GetEntriesQueryOptions = {}): Promise<CollectionEntryMap[K][]> {
 			return (await getEntries({ slug, ...options })) as unknown as CollectionEntryMap[K][];
 		}
 
@@ -162,8 +172,9 @@ function generateSchemas(config) {
 		import { z } from 'zod';
 	`;
     config.forms?.map((form) => {
+        const varName = toPascalCase(form.slug);
         code += `
-			export const ${form.slug}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
+			export const ${varName}FormSchema = ${generateZodSchemaStringFromFormFieldsAsString(form.fields)} \n
 		`;
     });
     writeFileSync(filePath, code);
@@ -177,13 +188,13 @@ function generateRemote(config) {
     code += `import { command } from '$app/server';\n`;
     code += `import { submitForm } from './api';\n`;
     const schemaImports = config.forms
-        .map((form) => `${form.slug}FormSchema`)
+        .map((form) => `${toPascalCase(form.slug)}FormSchema`)
         .join(', ');
     code += `import { ${schemaImports} } from './schemas';\n\n`;
     config.forms.forEach((form) => {
         const pascalSlug = toPascalCase(form.slug);
         code += `export const submit${pascalSlug}Command = command(\n`;
-        code += `\t${form.slug}FormSchema,\n`;
+        code += `\t${pascalSlug}FormSchema,\n`;
         code += `\tasync (data) => {\n`;
         code += `\t\tawait submitForm('${form.slug}', data);\n`;
         code += `\t}\n`;

package/dist/core/server/media/operations/purgeImageStyles.d.ts

@@ -0,0 +1,7 @@
+export declare function getImageStylesStats(): Promise<{
+    count: number;
+}>;
+export declare function purgeAllImageStyles(): Promise<{
+    deletedCount: number;
+    filesDeleted: number;
+}>;

package/dist/core/server/media/operations/purgeImageStyles.js

@@ -0,0 +1,25 @@
+import { getCMS } from '../../../cms.js';
+export async function getImageStylesStats() {
+    const styles = await getCMS().databaseAdapter.getAllImageStyles();
+    return { count: styles.length };
+}
+export async function purgeAllImageStyles() {
+    const cms = getCMS();
+    const styles = await cms.databaseAdapter.getAllImageStyles();
+    // Delete files from disk
+    let filesDeleted = 0;
+    for (const style of styles) {
+        const filename = style.url.split('/').pop();
+        if (filename) {
+            try {
+                await cms.filesAdapter.deleteFile(filename);
+                filesDeleted++;
+            }
+            catch {
+                // File may not exist
+            }
+        }
+    }
+    const deletedCount = await cms.databaseAdapter.deleteAllImageStyles();
+    return { deletedCount, filesDeleted };
+}

package/dist/core/server/media/operations/reconcileMedia.d.ts

@@ -0,0 +1,12 @@
+export interface ReconciliationReport {
+    orphanedDisk: string[];
+    missingDisk: {
+        table: string;
+        id: string;
+        url: string;
+    }[];
+}
+export declare function getReconciliationReport(): Promise<ReconciliationReport>;
+export declare function deleteOrphanedDiskFiles(): Promise<{
+    deletedCount: number;
+}>;

package/dist/core/server/media/operations/reconcileMedia.js

@@ -0,0 +1,62 @@
+import { getCMS } from '../../../cms.js';
+export async function getReconciliationReport() {
+    const cms = getCMS();
+    const diskFiles = await cms.filesAdapter.listFiles();
+    // Collect all known URLs from DB
+    const mediaFiles = await cms.databaseAdapter.getMediaFiles({ data: {} });
+    const imageStyles = await cms.databaseAdapter.getAllImageStyles();
+    const dbFilenames = new Set();
+    for (const mf of mediaFiles) {
+        const fn = mf.url.split('/').pop();
+        if (fn)
+            dbFilenames.add(fn);
+        if (mf.thumbnailUrl) {
+            const tfn = mf.thumbnailUrl.split('/').pop();
+            if (tfn)
+                dbFilenames.add(tfn);
+        }
+        if (mf.posterUrl) {
+            const pfn = mf.posterUrl.split('/').pop();
+            if (pfn)
+                dbFilenames.add(pfn);
+        }
+    }
+    for (const is of imageStyles) {
+        const fn = is.url.split('/').pop();
+        if (fn)
+            dbFilenames.add(fn);
+    }
+    // Orphaned: on disk but not in DB
+    const orphanedDisk = diskFiles.filter((f) => !dbFilenames.has(f));
+    // Missing: in DB but not on disk
+    const diskSet = new Set(diskFiles);
+    const missingDisk = [];
+    for (const mf of mediaFiles) {
+        const fn = mf.url.split('/').pop();
+        if (fn && !diskSet.has(fn)) {
+            missingDisk.push({ table: 'media_files', id: mf.id, url: mf.url });
+        }
+    }
+    for (const is of imageStyles) {
+        const fn = is.url.split('/').pop();
+        if (fn && !diskSet.has(fn)) {
+            missingDisk.push({ table: 'image_styles', id: is.id, url: is.url });
+        }
+    }
+    return { orphanedDisk, missingDisk };
+}
+export async function deleteOrphanedDiskFiles() {
+    const cms = getCMS();
+    const report = await getReconciliationReport();
+    let deletedCount = 0;
+    for (const filename of report.orphanedDisk) {
+        try {
+            await cms.filesAdapter.deleteFile(filename);
+            deletedCount++;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { deletedCount };
+}

package/dist/core/server/media/styles/operations/createMediaStyle.js

@@ -1,7 +1,18 @@
 import { getCMS } from '../../../../cms.js';
 import { generateImageStyle } from '../sharp/generateImageStyle.js';
 export async function createImageStyle(mediaFileId, style) {
+    const cms = getCMS();
+    // Check for existing style to clean up old file after upsert
+    const existing = await cms.databaseAdapter.getImageStyle(mediaFileId, style);
+    const oldUrl = existing?.url;
     const imageStyleFile = await generateImageStyle(mediaFileId, style);
-    const imageStyle = await getCMS().databaseAdapter.createImageStyle(mediaFileId, imageStyleFile, style);
+    const imageStyle = await cms.databaseAdapter.createImageStyle(mediaFileId, imageStyleFile, style);
+    // Delete old file from disk if URL changed
+    if (oldUrl && oldUrl !== imageStyle.url) {
+        const oldFilename = oldUrl.split('/').pop();
+        if (oldFilename) {
+            cms.filesAdapter.deleteFile(oldFilename).catch((e) => console.warn('Old style file cleanup failed:', e));
+        }
+    }
     return imageStyle;
 }

package/dist/db-postgres/index.js

@@ -326,19 +326,19 @@ export function pg(config) {
             };
         },
         createImageStyle: async (mediaFileId, file, style) => {
-            const [imageStyle] = await db
-                .insert(schema.imageStylesTable)
-                .values({
-                ...style,
-                url: file.url,
-                mimeType: file.mimeType ?? `image/${style.format}`,
-                mediaFileId: mediaFileId
-            })
-                .returning();
+            const mimeType = file.mimeType ?? `image/${style.format}`;
+            const rows = await db.execute(sql `
+				INSERT INTO image_styles (id, media_file_id, name, url, width, height, crop, quality, media, mime_type)
+				VALUES (gen_random_uuid(), ${mediaFileId}, ${style.name}, ${file.url}, ${style.width ?? null}, ${style.height ?? null}, ${style.crop ?? false}, ${style.quality ?? null}, ${style.media ?? null}, ${mimeType})
+				ON CONFLICT (media_file_id, name, COALESCE(width, 0), COALESCE(height, 0), COALESCE(quality, 0))
+				DO UPDATE SET url = EXCLUDED.url, mime_type = EXCLUDED.mime_type
+				RETURNING url, mime_type, media
+			`);
+            const row = rows[0];
             return {
-                url: imageStyle.url,
-                mimeType: imageStyle.mimeType,
-                media: imageStyle.media ? imageStyle.media : undefined
+                url: row.url,
+                mimeType: row.mime_type,
+                media: row.media ? row.media : undefined
             };
         },
         deleteMediaFile: async (id) => {
@@ -421,6 +421,19 @@ export function pg(config) {
                 .returning();
             const [file] = await hydrateFileTags(db, [rawFile]);
             return file;
+        },
+        getAllImageStyles: async () => {
+            return db
+                .select({
+                id: schema.imageStylesTable.id,
+                url: schema.imageStylesTable.url,
+                mediaFileId: schema.imageStylesTable.mediaFileId
+            })
+                .from(schema.imageStylesTable);
+        },
+        deleteAllImageStyles: async () => {
+            const result = await db.execute(sql `DELETE FROM image_styles`);
+            return Number(result.count ?? 0);
         }
     };
 }

package/dist/db-postgres/schema/imageStyle.js

@@ -11,3 +11,5 @@ export const imageStylesTable = pgTable('image_styles', {
     media: text('media'),
     mimeType: text('mime_type').notNull()
 });
+// NOTE: unique index on (media_file_id, name, COALESCE(width,0), COALESCE(height,0), COALESCE(quality,0))
+// is managed via SQL migration in src/lib/updates/0.5.8/index.ts (expression-based, not supported by Drizzle ORM)

package/dist/entity/index.d.ts

@@ -0,0 +1,26 @@
+import type { CMS } from '../core/cms.js';
+import type { DbEntry, DbEntryVersion, EntryData } from '../types/entries.js';
+interface EntityAPIOptions {
+    userId?: string;
+}
+interface CreateOptions {
+    skipValidation?: boolean;
+    sortOrder?: number;
+}
+export declare function createEntityAPI(cms: CMS, opts?: EntityAPIOptions): {
+    create(slug: string, data?: EntryData, options?: CreateOptions): Promise<DbEntry>;
+    update(entryId: string, data: EntryData, options?: {
+        skipValidation?: boolean;
+    }): Promise<DbEntryVersion>;
+    publish(entryId: string): Promise<void>;
+    unpublish(entryId: string): Promise<void>;
+    archive(entryId: string): Promise<void>;
+    unarchive(entryId: string): Promise<void>;
+    delete(entryId: string): Promise<void>;
+    list(slug: string, options?: {
+        includeArchived?: boolean;
+        onlyArchived?: boolean;
+    }): Promise<import("../types/entries.js").RawEntry[]>;
+    createAndPublish(slug: string, data: EntryData, options?: CreateOptions): Promise<DbEntry>;
+};
+export {};

package/dist/entity/index.js

@@ -0,0 +1,113 @@
+import { generateZodSchemaFromFields } from '../core/fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../core/fields/layoutUtils.js';
+import { getRawEntries } from '../core/server/entries/operations/get.js';
+export function createEntityAPI(cms, opts) {
+    const db = cms.databaseAdapter;
+    const userId = opts?.userId ?? 'system';
+    function validate(slug, data) {
+        const config = cms.getBySlug(slug);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), cms.languages);
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            throw Error('Invalid data: ' + JSON.stringify(result.error.flatten()));
+        }
+        return result.data;
+    }
+    return {
+        async create(slug, data, options) {
+            const config = cms.getBySlug(slug);
+            const type = config.type === 'collection' ? 'collection' : 'singleton';
+            const entry = await db.createEntry({
+                slug,
+                type,
+                sortOrder: options?.sortOrder ?? null
+            });
+            const entryData = data ?? {};
+            const validatedData = data && !options?.skipValidation ? validate(slug, entryData) : entryData;
+            await db.createEntryVersion({
+                entryId: entry.id,
+                data: validatedData,
+                createdBy: userId
+            });
+            return entry;
+        },
+        async update(entryId, data, options) {
+            const entries = await db.getEntries({ ids: [entryId] });
+            const entry = entries[0];
+            if (!entry)
+                throw Error('Entry not found');
+            const validatedData = !options?.skipValidation ? validate(entry.slug, data) : data;
+            const versions = await db.getEntryVersions({ entryIds: [entryId] });
+            const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
+            const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+            if (latestDraft) {
+                if (JSON.stringify(latestDraft.data) === JSON.stringify(validatedData)) {
+                    return latestDraft;
+                }
+                return db.updateEntryVersion({
+                    id: latestDraft.id,
+                    data: { data: validatedData, createdAt: new Date() }
+                });
+            }
+            return db.createEntryVersion({
+                entryId,
+                data: validatedData,
+                createdBy: userId
+            });
+        },
+        async publish(entryId) {
+            const versions = await db.getEntryVersions({ entryIds: [entryId] });
+            const entries = await db.getEntries({ ids: [entryId] });
+            const entry = entries[0];
+            if (!entry)
+                throw Error('Entry not found');
+            const draft = versions
+                .filter((v) => v.id !== entry.publishedVersionId)
+                .sort((a, b) => b.versionNumber - a.versionNumber)[0];
+            if (!draft)
+                throw Error('No draft to publish');
+            await db.updateEntry({
+                id: entryId,
+                data: {
+                    publishedVersionId: draft.id,
+                    publishedAt: new Date(),
+                    publishedBy: userId,
+                    archivedAt: null
+                }
+            });
+        },
+        async unpublish(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: {
+                    publishedVersionId: null,
+                    publishedAt: null,
+                    publishedBy: null
+                }
+            });
+        },
+        async archive(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: { archivedAt: new Date() }
+            });
+        },
+        async unarchive(entryId) {
+            await db.updateEntry({
+                id: entryId,
+                data: { archivedAt: null }
+            });
+        },
+        async delete(entryId) {
+            await db.deleteEntry({ id: entryId });
+        },
+        async list(slug, options) {
+            return getRawEntries({ slug, ...options });
+        },
+        async createAndPublish(slug, data, options) {
+            const entry = await this.create(slug, data, options);
+            await this.publish(entry.id);
+            return entry;
+        }
+    };
+}

package/dist/files-local/index.js

@@ -1,6 +1,6 @@
 import { basename, extname, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { readFile, writeFile, rename, unlink, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, rename, unlink, mkdir, readdir } from 'node:fs/promises';
 import sharp from 'sharp';
 import ffmpeg from 'fluent-ffmpeg';
 import { fileURLToPath } from 'url';
@@ -301,6 +301,16 @@ export function local() {
             catch {
                 // File may already be deleted
             }
+        },
+        listFiles: async () => {
+            try {
+                await ensureDir(fullDir);
+                const entries = await readdir(fullDir, { withFileTypes: true });
+                return entries.filter((e) => e.isFile()).map((e) => e.name);
+            }
+            catch {
+                return [];
+            }
         }
     };
 }