includio-cms 0.7.2 → 0.13.1

package/dist/core/server/fields/utils/imageStyles.js

@@ -66,37 +66,53 @@ export async function getImageStyles(field, val) {
     const stylesArr = expandStyleFormats(rawStyles, originalFormat);
     const [styles, blurDataUrl] = await Promise.all([
         Promise.all(stylesArr.map(async (style) => {
-            const styleDbData = await getImageStyle(val.id, style);
-            const result = {
-                url: styleDbData.url,
-                media: styleDbData.media,
-                mimeType: styleDbData.mimeType
-            };
-            // srcset expansion: generate width variants
-            if (style.srcset && style.srcset.length > 0 && val.width) {
-                const widths = style.srcset.filter((w) => w <= (val.width ?? 0));
-                if (widths.length > 0) {
-                    const variants = await Promise.all(widths.map(async (w) => {
-                        const variantStyle = {
-                            ...style,
-                            name: `${style.name}_${w}w`,
-                            width: w,
-                            srcset: undefined,
-                            sizes: undefined
-                        };
-                        const variantData = await getImageStyle(val.id, variantStyle);
-                        return `${variantData.url} ${w}w`;
-                    }));
-                    result.srcset = variants.join(', ');
-                    result.sizes = style.sizes;
+            try {
+                const styleDbData = await getImageStyle(val.id, style);
+                const result = {
+                    url: styleDbData.url,
+                    media: styleDbData.media,
+                    mimeType: styleDbData.mimeType
+                };
+                // srcset expansion: generate width variants
+                if (style.srcset && style.srcset.length > 0 && val.width) {
+                    const widths = style.srcset.filter((w) => w <= (val.width ?? 0));
+                    if (widths.length > 0) {
+                        const variants = await Promise.all(widths.map(async (w) => {
+                            try {
+                                const variantStyle = {
+                                    ...style,
+                                    name: `${style.name}_${w}w`,
+                                    width: w,
+                                    srcset: undefined,
+                                    sizes: undefined
+                                };
+                                const variantData = await getImageStyle(val.id, variantStyle);
+                                return `${variantData.url} ${w}w`;
+                            }
+                            catch (e) {
+                                console.warn(`[CMS] Failed to generate srcset variant ${w}w for style "${style.name}" of media ${val.id}:`, e);
+                                return null;
+                            }
+                        }));
+                        const validVariants = variants.filter((v) => v !== null);
+                        if (validVariants.length > 0) {
+                            result.srcset = validVariants.join(', ');
+                            result.sizes = style.sizes;
+                        }
+                    }
                 }
+                return [style.name, result];
+            }
+            catch (e) {
+                console.warn(`[CMS] Failed to generate image style "${style.name}" for media ${val.id}:`, e);
+                return null;
             }
-            return [style.name, result];
         })),
         ensureBlurDataUrl(val)
     ]);
+    const validStyles = styles.filter((s) => s !== null);
     return {
-        styles: Object.fromEntries(styles),
+        styles: Object.fromEntries(validStyles),
         blurDataUrl
     };
 }

package/dist/core/server/fields/utils/resolveMedia.js

@@ -9,12 +9,7 @@ export async function resolveMediaWithStyles(mediaIds, styles) {
         return {};
     const cms = getCMS();
     const files = await cms.databaseAdapter.getMediaFiles({ data: { ids: mediaIds } });
-    // Synthetic ImageField to pass to getImageStyles
-    const syntheticField = {
-        type: 'image',
-        slug: '_resolved',
-        styles: styles ?? []
-    };
+    const syntheticField = { styles: styles ?? [] };
     const entries = await Promise.all(files.map(async (file) => {
         const { styles: resolvedStyles, blurDataUrl } = await getImageStyles(syntheticField, file);
         return [file.id, { data: file, styles: resolvedStyles, blurDataUrl }];

package/dist/core/server/forms/submissions/operations/delete.js

@@ -1,9 +1,33 @@
 import { getCMS } from '../../../../cms.js';
+const PRIVATE_FILE_PREFIX = '/admin/api/media/private/';
+async function cleanupPrivateFiles(data) {
+    const adapter = getCMS().filesAdapter;
+    if (!adapter.deletePrivateFile)
+        return;
+    for (const value of Object.values(data)) {
+        if (typeof value === 'string' && value.startsWith(PRIVATE_FILE_PREFIX)) {
+            const filename = value.slice(PRIVATE_FILE_PREFIX.length);
+            if (filename && !filename.includes('/') && !filename.includes('..')) {
+                try {
+                    await adapter.deletePrivateFile(filename);
+                }
+                catch {
+                    // best-effort cleanup
+                }
+            }
+        }
+    }
+}
 export const deleteFormSubmission = async (id) => {
-    return getCMS().databaseAdapter.deleteFormSubmission(id);
+    const cms = getCMS();
+    const submission = await cms.databaseAdapter.getFormSubmission(id);
+    if (submission?.data) {
+        await cleanupPrivateFiles(submission.data);
+    }
+    return cms.databaseAdapter.deleteFormSubmission(id);
 };
 export const deleteFormSubmissions = async (ids) => {
     for (const id of ids) {
-        await getCMS().databaseAdapter.deleteFormSubmission(id);
+        await deleteFormSubmission(id);
     }
 };

package/dist/core/server/forms/submissions/utils/parseMultipart.d.ts

@@ -0,0 +1,2 @@
+import type { FormField } from '../../../../../types/formFields.js';
+export declare function parseFormDataForSubmission(formData: FormData, fields: FormField[]): Promise<Record<string, unknown>>;

package/dist/core/server/forms/submissions/utils/parseMultipart.js

@@ -0,0 +1,75 @@
+import { uploadPrivateFile } from '../../../media/operations/uploadPrivateFile.js';
+const SAFE_MIME_ALLOWLIST = new Set([
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'application/pdf'
+]);
+const MAGIC_BYTES = [
+    ['image/jpeg', [0xff, 0xd8, 0xff]],
+    ['image/png', [0x89, 0x50, 0x4e, 0x47]],
+    ['image/gif', [0x47, 0x49, 0x46]],
+    ['image/webp', [0x52, 0x49, 0x46, 0x46]], // RIFF
+    ['application/pdf', [0x25, 0x50, 0x44, 0x46]] // %PDF
+];
+const DEFAULT_MAX_SIZE = 10 * 1024 * 1024; // 10MB
+const HARD_MAX_SIZE = 25 * 1024 * 1024; // 25MB
+function validateMagicBytes(buffer, declaredMime) {
+    for (const [mime, bytes] of MAGIC_BYTES) {
+        if (mime !== declaredMime)
+            continue;
+        if (buffer.length < bytes.length)
+            return false;
+        return bytes.every((b, i) => buffer[i] === b);
+    }
+    return false;
+}
+export async function parseFormDataForSubmission(formData, fields) {
+    const result = {};
+    const fileFields = new Map(fields.filter((f) => f.type === 'file').map((f) => [f.slug, f]));
+    for (const field of fields) {
+        const raw = formData.get(field.slug);
+        if (fileFields.has(field.slug)) {
+            if (!raw || !(raw instanceof File) || raw.size === 0) {
+                result[field.slug] = '';
+                continue;
+            }
+            const file = raw;
+            const fieldConfig = fileFields.get(field.slug);
+            const maxSize = Math.min(fieldConfig.maxSize ?? DEFAULT_MAX_SIZE, HARD_MAX_SIZE);
+            if (file.size > maxSize) {
+                throw new Error(`File "${field.slug}" exceeds max size (${Math.round(maxSize / 1024 / 1024)}MB)`);
+            }
+            if (!SAFE_MIME_ALLOWLIST.has(file.type)) {
+                throw new Error(`File "${field.slug}" has disallowed MIME type: ${file.type}`);
+            }
+            if (fieldConfig.accept) {
+                const accepted = fieldConfig.accept.split(',').map((s) => s.trim());
+                const mimeOk = accepted.some((pattern) => {
+                    if (pattern.endsWith('/*')) {
+                        return file.type.startsWith(pattern.replace('/*', '/'));
+                    }
+                    return file.type === pattern;
+                });
+                if (!mimeOk) {
+                    throw new Error(`File "${field.slug}" type ${file.type} not in accept list: ${fieldConfig.accept}`);
+                }
+            }
+            const buffer = new Uint8Array(await file.arrayBuffer());
+            if (!validateMagicBytes(buffer, file.type)) {
+                throw new Error(`File "${field.slug}" content does not match declared MIME type ${file.type}`);
+            }
+            const privateFile = await uploadPrivateFile(file);
+            result[field.slug] = privateFile.url;
+            continue;
+        }
+        if (field.type === 'checkbox') {
+            result[field.slug] = raw === 'true' || raw === '1';
+        }
+        else {
+            result[field.slug] = typeof raw === 'string' ? raw : '';
+        }
+    }
+    return result;
+}

package/dist/core/server/generator/fields.d.ts

@@ -2,3 +2,9 @@ import type { Field } from '../../../types/fields.js';
 import type { CustomFieldDefinition } from '../../../types/plugins.js';
 export declare function setGeneratorCustomFields(customFields: Map<string, CustomFieldDefinition>): void;
 export declare function generateTsTypeFromFields(fields: Field[]): string;
+export declare function generateFlatTsTypeFromFields(fields: Field[]): string;
+export interface InlineBlockTypeDef {
+    slug: string;
+    fields: Field[];
+}
+export declare function generateInlineBlockTypeString(block: InlineBlockTypeDef): string;

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

@@ -6,7 +6,6 @@ export function setGeneratorCustomFields(customFields) {
 function getFieldTypeAsString(field) {
     switch (field.type) {
         case 'text':
-        case 'richtext':
         case 'date':
         case 'datetime':
             return 'string';
@@ -14,10 +13,6 @@ function getFieldTypeAsString(field) {
             return 'StructuredContentDoc';
         case 'radio':
             return field.options.map((opt) => `'${opt.value.trim()}'`).join(' | ');
-        case 'image': {
-            const base = field.multiple ? 'ImageFieldData[]' : 'ImageFieldData';
-            return base + (field.required ? '' : ' | null');
-        }
         case 'media': {
             const base = field.multiple
                 ? '(ImageFieldData | VideoFieldData)[]'
@@ -99,3 +94,46 @@ export function generateTsTypeFromFields(fields) {
     ${fields.map((f) => `  ${f.slug}${f.required || f.type === 'seo' ? '' : '?'}: ${getFieldTypeAsString(f)}`).join(';\n')};
   }`;
 }
+export function generateFlatTsTypeFromFields(fields) {
+    return `{
+    ${fields.map((f) => `  ${f.slug}${f.required || f.type === 'seo' ? '' : '?'}: ${getFlatFieldTypeAsString(f)}`).join(';\n')};
+  }`;
+}
+function getFlatFieldTypeAsString(field) {
+    switch (field.type) {
+        case 'media': {
+            const base = field.multiple
+                ? '(ImageFieldData | VideoFieldData)[]'
+                : 'ImageFieldData | VideoFieldData';
+            return base + (field.required ? '' : ' | null');
+        }
+        case 'relation': {
+            const name = toPascalCase(field.collection);
+            return field.multiple ? `${name}[]` : name;
+        }
+        case 'object':
+            return `{
+				_slug: '${field.slug}';
+				${field.fields.map((f) => `${f.slug}${f.required ? '' : '?'}: ${getFlatFieldTypeAsString(f)}`).join(';\n')};
+			}`;
+        case 'blocks':
+            return `
+			(
+			${field.of
+                .map((f) => `
+				{
+					_slug: '${f.slug}';
+					${f.fields.map((f) => `${f.slug}${f.required ? '' : '?'}: ${getFlatFieldTypeAsString(f)}`).join(';\n')};
+				}
+			`)
+                .join(' | ')}
+			)[]`;
+        default:
+            return getFieldTypeAsString(field);
+    }
+}
+export function generateInlineBlockTypeString(block) {
+    return `{
+    ${block.fields.map((f) => `  ${f.slug}${f.required ? '' : '?'}: ${getFlatFieldTypeAsString(f)}`).join(';\n')};
+  }`;
+}

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

@@ -50,6 +50,16 @@ export function generateZodSchemaFromFormFieldAsString(field) {
             code = `z.enum([${values.join(', ')}])`;
             break;
         }
+        case 'file': {
+            if (field.required) {
+                const msg = getErrorMsg(field);
+                code = 'z.string()' + (msg ? `.min(1, ${msg})` : '.min(1)');
+            }
+            else {
+                code = "z.string().optional().default('')";
+            }
+            break;
+        }
         default:
             code = 'z.any()';
     }

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

@@ -3,6 +3,7 @@ function getFormFieldTypeAsString(field) {
         case 'text':
         case 'email':
         case 'textarea':
+        case 'file':
             return 'string';
         case 'checkbox':
             return 'boolean';

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

@@ -1,6 +1,6 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { generateTsTypeFromFields, setGeneratorCustomFields } from './fields.js';
+import { generateTsTypeFromFields, generateFlatTsTypeFromFields, generateInlineBlockTypeString, setGeneratorCustomFields } from './fields.js';
 import { generateTsTypeFromFormFields } from './formFields.js';
 import { generateZodSchemaStringFromFormFieldsAsString } from './formFieldSchemaToString.js';
 import { toPascalCase } from './utils.js';
@@ -16,13 +16,18 @@ function generateTypesStringForRecords(type, records) {
     code += `
 	${records
         .map((single) => {
+        const fieldsType = generateFlatTsTypeFromFields(getFieldsFromConfig(single));
+        // Strip outer braces to inline fields into the interface
+        const innerFields = fieldsType.replace(/^\s*\{/, '').replace(/\}\s*$/, '');
         return `
 			export interface ${toPascalCase(single.slug)} {
-				id: string;
-				slug: string;
-				data: ${generateTsTypeFromFields(getFieldsFromConfig(single))}
-				publishedAt: Date | null;
-			};
+				_id: string;
+				_slug: string;
+				_type: string;
+				_publishedAt: Date | null;
+				_url?: string;
+				${innerFields}
+			}
 		`;
     })
         .join('\n')}
@@ -67,11 +72,43 @@ function generateTypesStringForForms(records) {
 	`;
     return code;
 }
+function collectInlineBlocks(fields) {
+    const blocks = new Map();
+    for (const field of fields) {
+        if (field.type === 'content') {
+            const cf = field;
+            if (cf.inlineBlocks) {
+                for (const block of cf.inlineBlocks) {
+                    if (!blocks.has(block.slug)) {
+                        blocks.set(block.slug, block.fields);
+                    }
+                }
+            }
+        }
+        if (field.type === 'object') {
+            const nested = collectInlineBlocks(field.fields);
+            for (const [slug, fields] of nested) {
+                if (!blocks.has(slug))
+                    blocks.set(slug, fields);
+            }
+        }
+        if (field.type === 'blocks') {
+            for (const obj of field.of) {
+                const nested = collectInlineBlocks(obj.fields);
+                for (const [slug, fields] of nested) {
+                    if (!blocks.has(slug))
+                        blocks.set(slug, fields);
+                }
+            }
+        }
+    }
+    return blocks;
+}
 function generateTypes(config) {
     const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
     const filePath = join(cmsDir, 'types.ts');
     let code = `// This file is auto-generated. Do not edit directly.\n\n`;
-    code += `import type { MediaFile, ImageFieldData, VideoFieldData, StructuredContentDoc } from 'includio-cms/types';\n\n`;
+    code += `import type { MediaFile, ImageFieldData, VideoFieldData, StructuredContentDoc, SCTypedInlineBlock } from 'includio-cms/types';\n\n`;
     if (config.singles && config.singles.length > 0) {
         code += generateTypesStringForRecords('single', Object.values(config.singles));
     }
@@ -81,6 +118,41 @@ function generateTypes(config) {
     if (config.forms && config.forms.length > 0) {
         code += generateTypesStringForForms(Object.values(config.forms));
     }
+    // Inline block types
+    const allInlineBlocks = new Map();
+    const allRecords = [...(config.singles ?? []), ...(config.collections ?? [])];
+    for (const record of allRecords) {
+        const blocks = collectInlineBlocks(getFieldsFromConfig(record));
+        for (const [slug, fields] of blocks) {
+            if (!allInlineBlocks.has(slug))
+                allInlineBlocks.set(slug, fields);
+        }
+    }
+    if (allInlineBlocks.size > 0) {
+        code += `\n// Inline block data types\n`;
+        for (const [slug, fields] of allInlineBlocks) {
+            const typeName = toPascalCase(slug) + 'BlockData';
+            code += `export type ${typeName} = ${generateInlineBlockTypeString({ slug, fields })};\n\n`;
+        }
+    }
+    // BlockDataMap per content field
+    for (const record of allRecords) {
+        const fields = getFieldsFromConfig(record);
+        for (const field of fields) {
+            if (field.type === 'content') {
+                const cf = field;
+                if (cf.inlineBlocks && cf.inlineBlocks.length > 0) {
+                    const mapName = toPascalCase(record.slug) + toPascalCase(field.slug) + 'BlockDataMap';
+                    code += `\nexport type ${mapName} = {\n`;
+                    for (const block of cf.inlineBlocks) {
+                        const key = block.slug.includes('-') ? `'${block.slug}'` : block.slug;
+                        code += `  ${key}: ${toPascalCase(block.slug)}BlockData;\n`;
+                    }
+                    code += `};\n`;
+                }
+            }
+        }
+    }
     code += `\n export type SiteLanguage =  ${config.languages.map((lang) => JSON.stringify(lang)).join(' | ')};\n\n`;
     writeFileSync(filePath, code);
 }
@@ -91,61 +163,57 @@ function generateAPI(config) {
     code += `
 	
 		import type { SingleEntryMap, SingleSlug, CollectionEntryMap, CollectionSlug, FormEntryMap, SiteLanguage } from './types';
-		import { getEntry, getEntries, createFormSubmission } from 'includio-cms/sveltekit/server';
+		import { getEntry, getEntries, countEntries, createFormSubmission } from 'includio-cms/sveltekit/server';
 
 	`;
     code += `
 
-		interface GetEntryQueryOptions {
+		interface GetEntryOptions {
 			id?: string;
 			status?: 'draft' | 'published' | 'scheduled' | 'archived';
 			dataValues?: Record<string, unknown>;
-		}
-
-		interface GetEntryOptions {
-
 		`;
     if (config.languages && config.languages.length > 0) {
         code += `
-			/**
-			 * Language code to fetch the entry in. Defaults to the first language in the CMS config.
-			 */
 			language?: SiteLanguage;
 				`;
     }
     code += `
-		
 		}
-		
+
+		interface GetEntriesOptions extends GetEntryOptions {
+			ids?: string[];
+			dataLike?: Record<string, unknown>;
+			dataILikeOr?: Record<string, unknown>;
+			orderBy?: { column: 'createdAt' | 'updatedAt' | 'sortOrder'; direction: 'asc' | 'desc' };
+			dataOrderBy?: { field: string; direction: 'asc' | 'desc' };
+			limit?: number;
+			offset?: number;
+		}
+
 		`;
     code += `
 
-		export async function getSingleEntry<K extends SingleSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<SingleEntryMap[K] | null> {
+		export async function getSingleEntry<K extends SingleSlug>(slug: K, options: GetEntryOptions = {}): Promise<SingleEntryMap[K] | null> {
 			return (await getEntry({
-			  ...data,
 				slug,
 				...options
 			})) as unknown as SingleEntryMap[K] | null;
 		}
 
-		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, data: GetEntryQueryOptions, options: GetEntryOptions): Promise<CollectionEntryMap[K] | null> {
+		export async function getCollectionEntry<K extends CollectionSlug>(slug: K, options: GetEntryOptions = {}): Promise<CollectionEntryMap[K] | null> {
 			return (await getEntry({
-			  ...data,
 				slug,
 				...options
 			})) as unknown as CollectionEntryMap[K] | null;
 		}
 
-		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: GetEntriesOptions = {}): Promise<CollectionEntryMap[K][]> {
+			return (await getEntries({ slug, ...options })) as unknown as CollectionEntryMap[K][];
 		}
 
-		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][];
+		export async function countCollectionEntries<K extends CollectionSlug>(slug: K, options: Omit<GetEntriesOptions, 'limit' | 'offset' | 'orderBy'> = {}): Promise<number> {
+			return countEntries({ slug, ...options });
 		}
 
 		${config.forms && config.forms.length > 0

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

@@ -1,4 +1,9 @@
 import type { GetMediaFilesOptions } from '../../../../types/adapters/db.js';
 import type { MediaFile } from '../../../../types/media.js';
 export declare function getFiles(options: GetMediaFilesOptions): Promise<MediaFile[]>;
+export declare function countFiles(options: GetMediaFilesOptions): Promise<number>;
+export declare function getMediaTagsWithCounts(): Promise<{
+    tag: import("../../../../types/media.js").MediaTag;
+    count: number;
+}[]>;
 export declare function getFile(fileId: string): Promise<MediaFile | null>;

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

@@ -3,6 +3,12 @@ import { z } from 'zod';
 export async function getFiles(options) {
     return getCMS().databaseAdapter.getMediaFiles(options);
 }
+export async function countFiles(options) {
+    return getCMS().databaseAdapter.countMediaFiles(options);
+}
+export async function getMediaTagsWithCounts() {
+    return getCMS().databaseAdapter.getMediaTagsWithCounts();
+}
 const fileSchema = z.string().uuid();
 export async function getFile(fileId) {
     const parsedFileId = fileSchema.safeParse(fileId);

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

@@ -0,0 +1,4 @@
+export declare function uploadPrivateFile(file: File): Promise<{
+    filename: string;
+    url: string;
+}>;

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

@@ -0,0 +1,8 @@
+import { getCMS } from '../../../cms.js';
+export async function uploadPrivateFile(file) {
+    const adapter = getCMS().filesAdapter;
+    if (!adapter.uploadPrivateFile) {
+        throw new Error('Private file uploads not supported by current files adapter');
+    }
+    return adapter.uploadPrivateFile(file);
+}

package/dist/core/server/media/styles/operations/batchGenerateStyles.d.ts

@@ -0,0 +1,16 @@
+export type BatchProgress = {
+    type: 'progress' | 'error' | 'done';
+    total: number;
+    processed: number;
+    created: number;
+    skipped: number;
+    currentFile?: string;
+    error?: string;
+};
+export declare function batchGenerateAllStyles(signal?: AbortSignal): AsyncGenerator<BatchProgress>;
+export declare function getStylesStatus(): Promise<{
+    processableImages: number;
+    expectedStyles: number;
+    existingStyles: number;
+    missingStyles: number;
+}>;