includio-cms 0.7.1 → 0.13.0

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

@@ -6,6 +6,7 @@ export const entryVersionsTable = pgTable('entry_version', {
     entryId: uuid('entry_id')
         .notNull()
         .references(() => entriesTable.id, { onDelete: 'cascade' }),
+    lang: text('lang').notNull(),
     versionNumber: integer('version_number').notNull(),
     data: jsonb('data').notNull().$type(),
     createdAt: timestamp('created_at').defaultNow().notNull(),

package/dist/entity/index.d.ts

@@ -8,12 +8,15 @@ interface CreateOptions {
     sortOrder?: number;
 }
 export declare function createEntityAPI(cms: CMS, opts?: EntityAPIOptions): {
-    create(slug: string, data?: EntryData, options?: CreateOptions): Promise<DbEntry>;
+    create(slug: string, data?: EntryData, options?: CreateOptions & {
+        lang?: string;
+    }): Promise<DbEntry>;
     update(entryId: string, data: EntryData, options?: {
         skipValidation?: boolean;
+        lang?: string;
     }): Promise<DbEntryVersion>;
-    publish(entryId: string): Promise<void>;
-    unpublish(entryId: string): Promise<void>;
+    publish(entryId: string, lang?: string): Promise<void>;
+    unpublish(entryId: string, lang?: string): Promise<void>;
     archive(entryId: string): Promise<void>;
     unarchive(entryId: string): Promise<void>;
     delete(entryId: string): Promise<void>;
@@ -21,6 +24,8 @@ export declare function createEntityAPI(cms: CMS, opts?: EntityAPIOptions): {
         includeArchived?: boolean;
         onlyArchived?: boolean;
     }): Promise<import("../types/entries.js").RawEntry[]>;
-    createAndPublish(slug: string, data: EntryData, options?: CreateOptions): Promise<DbEntry>;
+    createAndPublish(slug: string, data: EntryData, options?: CreateOptions & {
+        lang?: string;
+    }): Promise<DbEntry>;
 };
 export {};

package/dist/entity/index.js

@@ -4,6 +4,7 @@ import { getRawEntries } from '../core/server/entries/operations/get.js';
 export function createEntityAPI(cms, opts) {
     const db = cms.databaseAdapter;
     const userId = opts?.userId ?? 'system';
+    const defaultLang = cms.languages[0];
     function validate(slug, data) {
         const config = cms.getBySlug(slug);
         const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), cms.languages);
@@ -22,24 +23,27 @@ export function createEntityAPI(cms, opts) {
                 type,
                 sortOrder: options?.sortOrder ?? null
             });
+            const lang = options?.lang ?? defaultLang;
             const entryData = data ?? {};
             const validatedData = data && !options?.skipValidation ? validate(slug, entryData) : entryData;
             await db.createEntryVersion({
                 entryId: entry.id,
+                lang,
                 data: validatedData,
                 createdBy: userId
             });
             return entry;
         },
         async update(entryId, data, options) {
+            const lang = options?.lang ?? defaultLang;
             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 versions = await db.getEntryVersions({ entryIds: [entryId], lang });
             const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
-            const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+            const latestDraft = sorted.find((v) => v.publishedAt == null);
             if (latestDraft) {
                 if (JSON.stringify(latestDraft.data) === JSON.stringify(validatedData)) {
                     return latestDraft;
@@ -51,40 +55,36 @@ export function createEntityAPI(cms, opts) {
             }
             return db.createEntryVersion({
                 entryId,
+                lang,
                 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');
+        async publish(entryId, lang) {
+            const targetLang = lang ?? defaultLang;
+            const versions = await db.getEntryVersions({ entryIds: [entryId], lang: targetLang });
             const draft = versions
-                .filter((v) => v.id !== entry.publishedVersionId)
+                .filter((v) => v.publishedAt == null)
                 .sort((a, b) => b.versionNumber - a.versionNumber)[0];
             if (!draft)
                 throw Error('No draft to publish');
-            await db.updateEntry({
-                id: entryId,
+            await db.updateEntryVersion({
+                id: draft.id,
                 data: {
-                    publishedVersionId: draft.id,
                     publishedAt: new Date(),
-                    publishedBy: userId,
-                    archivedAt: null
+                    publishedBy: userId
                 }
             });
         },
-        async unpublish(entryId) {
-            await db.updateEntry({
-                id: entryId,
-                data: {
-                    publishedVersionId: null,
-                    publishedAt: null,
-                    publishedBy: null
-                }
-            });
+        async unpublish(entryId, lang) {
+            const targetLang = lang ?? defaultLang;
+            const versions = await db.getEntryVersions({ entryIds: [entryId], lang: targetLang });
+            await Promise.all(versions
+                .filter((v) => v.publishedAt !== null)
+                .map((v) => db.updateEntryVersion({
+                id: v.id,
+                data: { publishedAt: null, publishedBy: null }
+            })));
         },
         async archive(entryId) {
             await db.updateEntry({
@@ -106,7 +106,7 @@ export function createEntityAPI(cms, opts) {
         },
         async createAndPublish(slug, data, options) {
             const entry = await this.create(slug, data, options);
-            await this.publish(entry.id);
+            await this.publish(entry.id, options?.lang);
             return entry;
         }
     };

package/dist/files-local/index.js

@@ -10,6 +10,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 global.__dirname = __dirname ?? '';
 const fullDir = process.env.NODE_ENV === 'production' ? `/data/uploads` : `./static/uploads`;
+const privateDir = process.env.NODE_ENV === 'production' ? `/data/private-uploads` : `./data/private-uploads`;
 // Ustawienie ścieżek do ffmpeg
 const ffmpegPath = process.env.FFMPEG_PATH || '/usr/bin/ffmpeg';
 const ffprobePath = process.env.FFPROBE_PATH || '/usr/bin/ffprobe';
@@ -311,6 +312,48 @@ export function local() {
             catch {
                 return [];
             }
+        },
+        uploadPrivateFile: async (file) => {
+            await ensureDir(privateDir);
+            const ext = extname(file.name);
+            const rawName = basename(file.name, ext);
+            const safeName = sanitizeFilename(rawName);
+            const filename = `${randomUUID().slice(0, 8)}-${safeName}${ext}`;
+            const filepath = resolve(privateDir, filename);
+            if (!filepath.startsWith(resolve(privateDir))) {
+                throw new Error('Invalid filename');
+            }
+            const arrayBuffer = await file.arrayBuffer();
+            await writeFile(filepath, Buffer.from(arrayBuffer));
+            return {
+                filename,
+                url: `/admin/api/media/private/${filename}`
+            };
+        },
+        downloadPrivateFile: async (filename) => {
+            const filepath = resolve(privateDir, filename);
+            if (!filepath.startsWith(resolve(privateDir))) {
+                return null;
+            }
+            try {
+                const data = await readFile(filepath);
+                return new File([data], filename);
+            }
+            catch {
+                return null;
+            }
+        },
+        deletePrivateFile: async (filename) => {
+            const filepath = resolve(privateDir, filename);
+            if (!filepath.startsWith(resolve(privateDir))) {
+                throw new Error('Invalid filename');
+            }
+            try {
+                await unlink(filepath);
+            }
+            catch {
+                // File may already be deleted
+            }
         }
     };
 }

package/dist/sveltekit/components/preview.svelte

@@ -1,9 +1,5 @@
-<script lang="ts" generics="T extends { data: PopulatedEntryData }">
-	import type { PopulatedEntryData } from '../../types/entries.js';
+<script lang="ts" generics="T extends Record<string, unknown>">
 	import { onMount, type Snippet } from 'svelte';
-	import { enableHybridEditing } from './hybrid-context.js';
-
-	enableHybridEditing();
 
 	type Props = {
 		entry: T;
@@ -13,230 +9,10 @@
 	let { entry, child }: Props = $props();
 
 	let previewData: T = $state(entry);
-	let hybridModeEnabled = $state(false);
-	let highlightedPath = $state<string | null>(null);
 	let parentOrigin: string | null = null;
 
-	/**
-	 * Checks if a value looks like a UUID reference
-	 */
-	function isUUID(value: unknown): value is string {
-		if (typeof value !== 'string') return false;
-		return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-	}
-
-	/**
-	 * Checks if a value is a block with slug and data (e.g., {slug: "card", data: {...}})
-	 */
-	function isBlock(value: unknown): value is { slug: string; data: Record<string, unknown> } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'slug' in value &&
-			'data' in value &&
-			typeof (value as Record<string, unknown>).slug === 'string'
-		);
-	}
-
-	/**
-	 * Checks if a value is a resolved media/file object with nested data
-	 * e.g., { data: { id: "...", url: "...", ... }, styles: {} }
-	 */
-	function isResolvedMediaBlock(
-		value: unknown
-	): value is { data: { id: string; [key: string]: unknown }; [key: string]: unknown } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'data' in value &&
-			typeof (value as Record<string, unknown>).data === 'object' &&
-			(value as Record<string, unknown>).data !== null &&
-			'id' in ((value as Record<string, unknown>).data as Record<string, unknown>) &&
-			'url' in ((value as Record<string, unknown>).data as Record<string, unknown>)
-		);
-	}
-
-	/**
-	 * Checks if a value is a simple resolved reference (has id UUID at top level)
-	 * e.g., { id: "...", slug: "...", type: "collection" } or { id: "...", url: "...", width: 800 }
-	 */
-	function isResolvedReference(
-		value: unknown
-	): value is { id: string; [key: string]: unknown } {
-		return (
-			typeof value === 'object' &&
-			value !== null &&
-			'id' in value &&
-			typeof (value as Record<string, unknown>).id === 'string' &&
-			isUUID((value as Record<string, unknown>).id)
-		);
-	}
-
-	/**
-	 * Checks if a value looks like a localized object (has language keys like 'pl', 'en')
-	 */
-	function isLocalizedObject(value: unknown): value is Record<string, unknown> {
-		if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
-		const keys = Object.keys(value);
-		// Common language codes
-		const langCodes = ['pl', 'en', 'de', 'fr', 'es', 'it', 'uk', 'cs', 'sk'];
-		return keys.length > 0 && keys.every((k) => langCodes.includes(k));
-	}
-
-	/**
-	 * Deep merges form data with original populated data, preserving resolved references
-	 * when the ID hasn't changed. This allows live preview to work without losing
-	 * populated image/file/relation data.
-	 */
-	function deepMergeWithReferences(
-		original: PopulatedEntryData,
-		updates: Record<string, unknown>
-	): PopulatedEntryData {
-		const result: PopulatedEntryData = { ...original };
-
-		for (const key in updates) {
-			const updateValue = updates[key];
-			const originalValue = original[key];
-
-			// Case 1: Update is a UUID string, original is a resolved media block { data: { id, url, ... }, styles: {} }
-			if (isUUID(updateValue) && isResolvedMediaBlock(originalValue)) {
-				if (originalValue.data.id === updateValue) {
-					// Same ID - keep the fully populated original
-					continue;
-				} else {
-					// Different ID - mark as pending
-					result[key] = { data: { id: updateValue, _pending: true }, styles: {} };
-				}
-				continue;
-			}
-
-			// Case 2: Update is a UUID string, original is a simple resolved reference { id, url, ... }
-			if (isUUID(updateValue) && isResolvedReference(originalValue)) {
-				if (originalValue.id === updateValue) {
-					// Same ID - keep the fully populated original
-					continue;
-				} else {
-					// Different ID - mark as pending
-					result[key] = { id: updateValue, _pending: true };
-				}
-				continue;
-			}
-
-			// Case 3: Both are arrays - merge based on index and slug matching for blocks
-			if (Array.isArray(updateValue) && Array.isArray(originalValue)) {
-				const mergedArray: unknown[] = [];
-
-				for (let i = 0; i < updateValue.length; i++) {
-					const updateItem = updateValue[i];
-
-					// Handle UUID in array
-					if (isUUID(updateItem)) {
-						// Find matching resolved object in original by ID
-						const matchingOriginal = originalValue.find((orig) => {
-							if (isResolvedMediaBlock(orig)) return orig.data.id === updateItem;
-							if (isResolvedReference(orig)) return orig.id === updateItem;
-							return false;
-						});
-						if (matchingOriginal) {
-							mergedArray.push(matchingOriginal);
-						} else {
-							mergedArray.push({ id: updateItem, _pending: true });
-						}
-						continue;
-					}
-
-					// Handle blocks with slug and data
-					if (isBlock(updateItem)) {
-						// Try to find matching block in original by same index and slug
-						const originalItem = originalValue[i];
-						if (isBlock(originalItem) && originalItem.slug === updateItem.slug) {
-							// Recursively merge the data inside the block
-							mergedArray.push({
-								slug: updateItem.slug,
-								data: deepMergeWithReferences(
-									originalItem.data as PopulatedEntryData,
-									updateItem.data
-								)
-							});
-						} else {
-							// No matching block, use update as-is
-							mergedArray.push(updateItem);
-						}
-						continue;
-					}
-
-					// Handle other nested objects
-					if (typeof updateItem === 'object' && updateItem !== null) {
-						const originalItem = originalValue[i];
-						if (typeof originalItem === 'object' && originalItem !== null) {
-							mergedArray.push(
-								deepMergeWithReferences(
-									originalItem as PopulatedEntryData,
-									updateItem as Record<string, unknown>
-								)
-							);
-						} else {
-							mergedArray.push(updateItem);
-						}
-						continue;
-					}
-
-					// Primitive value
-					mergedArray.push(updateItem);
-				}
-
-				result[key] = mergedArray;
-				continue;
-			}
-
-			// Case 4: Update is localized object {pl: "..."}, original is plain string
-			// Use the current language value or first available
-			if (isLocalizedObject(updateValue) && typeof originalValue === 'string') {
-				const langs = Object.keys(updateValue);
-				// Try 'pl' first, then first available
-				result[key] = updateValue['pl'] ?? updateValue[langs[0]] ?? originalValue;
-				continue;
-			}
-
-			// Case 5: Both are blocks with slug/data - merge recursively
-			if (
-				isBlock(updateValue) &&
-				isBlock(originalValue) &&
-				updateValue.slug === originalValue.slug
-			) {
-				result[key] = {
-					slug: updateValue.slug,
-					data: deepMergeWithReferences(originalValue.data as PopulatedEntryData, updateValue.data)
-				};
-				continue;
-			}
-
-			// Case 6: Both are nested objects (but not arrays) - recursively merge
-			if (
-				typeof updateValue === 'object' &&
-				updateValue !== null &&
-				!Array.isArray(updateValue) &&
-				typeof originalValue === 'object' &&
-				originalValue !== null &&
-				!Array.isArray(originalValue)
-			) {
-				result[key] = deepMergeWithReferences(
-					originalValue as PopulatedEntryData,
-					updateValue as Record<string, unknown>
-				);
-				continue;
-			}
-
-			// Case 7: Simple value replacement (strings, numbers, booleans, etc.)
-			result[key] = updateValue;
-		}
-
-		return result;
-	}
-
 	onMount(() => {
 		function handleMessage(e: MessageEvent) {
-			// Accept first message from any origin (handshake), then lock to that origin
 			if (!parentOrigin) {
 				parentOrigin = e.origin;
 			} else if (e.origin !== parentOrigin) {
@@ -244,103 +20,17 @@
 			}
 
 			if (e.data.type === 'preview-update') {
-				// Merge form data with current preview data, preserving resolved references
-				previewData = {
-					...previewData,
-					data: deepMergeWithReferences(previewData.data as PopulatedEntryData, e.data.data)
-				} as T;
-			}
-
-			if (e.data.type === 'hybrid-mode-enable') {
-				hybridModeEnabled = e.data.enabled;
-				updateHybridClickHandlers();
-			}
-
-			// Highlight from form focus
-			if (e.data.type === 'hybrid-highlight') {
-				highlightedPath = e.data.path;
-				updateHighlight();
+				previewData = { ...previewData, ...e.data.data } as T;
 			}
 		}
 
 		window.addEventListener('message', handleMessage);
-		// Block link clicks in hybrid mode
-		document.addEventListener('click', handleLinkClick, true);
-
-		// Signal to parent that preview is ready to receive data
 		window.parent.postMessage({ type: 'preview-ready' }, parentOrigin || '*');
 
 		return () => {
 			window.removeEventListener('message', handleMessage);
-			document.removeEventListener('click', handleLinkClick, true);
 		};
 	});
-
-	function updateHybridClickHandlers() {
-		// Remove existing handlers and styles
-		document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-			el.removeEventListener('click', handleHybridClick as EventListener);
-			(el as HTMLElement).classList.remove('hybrid-editable');
-		});
-
-		if (hybridModeEnabled) {
-			// Add click handlers and styles for hybrid elements
-			document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-				el.addEventListener('click', handleHybridClick as EventListener);
-				(el as HTMLElement).classList.add('hybrid-editable');
-			});
-		}
-	}
-
-	// Block all link navigation when in hybrid mode
-	function handleLinkClick(e: MouseEvent) {
-		if (!hybridModeEnabled) return;
-
-		const link = (e.target as HTMLElement).closest('a');
-		if (link && link.href) {
-			e.preventDefault();
-			e.stopPropagation();
-		}
-	}
-
-	function updateHighlight() {
-		// Remove all highlights
-		document.querySelectorAll('[data-hybrid-path]').forEach((el) => {
-			(el as HTMLElement).classList.remove('hybrid-highlighted');
-		});
-
-		// Add highlight to matching element
-		if (highlightedPath) {
-			const el = document.querySelector(`[data-hybrid-path="${highlightedPath}"]`) as HTMLElement;
-			if (el) {
-				el.classList.add('hybrid-highlighted');
-			}
-		}
-	}
-
-	function handleHybridClick(e: MouseEvent) {
-		e.preventDefault();
-		e.stopPropagation();
-
-		// Find the closest element with data-hybrid-path
-		const target = (e.target as HTMLElement).closest('[data-hybrid-path]') as HTMLElement;
-		if (!target) return;
-
-		const path = target.dataset.hybridPath;
-		if (path) {
-			// Normalize to dot notation (hero[0].data → hero.0.data)
-			const normalized = path.replace(/\[(\d+)\]/g, '.$1');
-			window.parent.postMessage({ type: 'hybrid-focus', path: normalized }, parentOrigin || '*');
-		}
-	}
-
-	// Re-apply handlers when previewData changes
-	$effect(() => {
-		if (previewData && hybridModeEnabled) {
-			// Small delay to ensure DOM is updated
-			setTimeout(updateHybridClickHandlers, 100);
-		}
-	});
 </script>
 
 {#if child}
@@ -350,17 +40,3 @@
 {:else}
 	<pre>{JSON.stringify(previewData, null, 2)}</pre>
 {/if}
-
-<style>
-	:global(.hybrid-editable) {
-		cursor: pointer;
-		outline: 2px dashed transparent;
-		outline-offset: 4px;
-		transition: outline-color 0.15s ease;
-	}
-
-	:global(.hybrid-editable:hover),
-	:global(.hybrid-highlighted) {
-		outline-color: #3b82f6;
-	}
-</style>

package/dist/sveltekit/components/preview.svelte.d.ts

@@ -1,8 +1,5 @@
-import type { PopulatedEntryData } from '../../types/entries.js';
 import { type Snippet } from 'svelte';
-declare function $$render<T extends {
-    data: PopulatedEntryData;
-}>(): {
+declare function $$render<T extends Record<string, unknown>>(): {
     props: {
         entry: T;
         child?: Snippet<[{
@@ -14,9 +11,7 @@ declare function $$render<T extends {
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<T extends {
-    data: PopulatedEntryData;
-}> {
+declare class __sveltets_Render<T extends Record<string, unknown>> {
     props(): ReturnType<typeof $$render<T>>['props'];
     events(): ReturnType<typeof $$render<T>>['events'];
     slots(): ReturnType<typeof $$render<T>>['slots'];
@@ -24,18 +19,12 @@ declare class __sveltets_Render<T extends {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <T extends {
-        data: PopulatedEntryData;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+    new <T extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
     } & ReturnType<__sveltets_Render<T>['exports']>;
-    <T extends {
-        data: PopulatedEntryData;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Preview: $$IsomorphicComponent;
-type Preview<T extends {
-    data: PopulatedEntryData;
-}> = InstanceType<typeof Preview<T>>;
+type Preview<T extends Record<string, unknown>> = InstanceType<typeof Preview<T>>;
 export default Preview;

package/dist/sveltekit/server/index.d.ts

@@ -1,5 +1,6 @@
 export { includioCMS } from './handle.js';
-export { getEntry, getEntries } from '../../core/server/entries/operations/get.js';
+export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
+export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';
 export { getPreviewEntry } from './preview.js';

package/dist/sveltekit/server/index.js

@@ -1,5 +1,6 @@
 export { includioCMS } from './handle.js';
-export { getEntry, getEntries } from '../../core/server/entries/operations/get.js';
+export { getEntry, getEntries, countEntries } from '../../core/server/entries/operations/get.js';
 export { createFormSubmission } from '../../core/server/forms/submissions/operations/create.js';
+export { parseFormDataForSubmission } from '../../core/server/forms/submissions/utils/parseMultipart.js';
 export { createConsentLog } from '../../core/server/consentLogs/operations/create.js';
 export { getPreviewEntry } from './preview.js';

package/dist/sveltekit/server/preview.js

@@ -9,11 +9,8 @@ export async function getPreviewEntry(event, options) {
     if (!authLocals.user || !authLocals.session) {
         throw new Error('Unauthorized');
     }
-    if (preview) {
-        return getEntryVersion({
-            id: preview,
-            language: options.language
-        });
-    }
-    return null;
+    return getEntryVersion({
+        id: preview,
+        language: options.language
+    });
 }