includio-cms 0.1.4 → 0.5.1

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

@@ -1,5 +1,6 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
 import { getEntries } from '../entries/operations/get.js';
+import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
 export async function resolveUrlFields(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -26,7 +27,7 @@ export async function resolveUrlFields(data, fields, language) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -37,14 +38,29 @@ export async function resolveUrlFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'array':
+                    if (field.of === 'url' && Array.isArray(val)) {
+                        for (const item of val) {
+                            const parsedVal = urlFieldDataWithRelationSchema.safeParse(item);
+                            if (parsedVal.success) {
+                                entriesIds.push(parsedVal.data.id);
+                            }
+                        }
+                    }
+                    break;
             }
         }
     };
     collectIds(data, fields);
-    let entriesMap = {};
+    const slugMap = {};
     if (entriesIds.length > 0) {
         const entries = await getEntries({ ids: entriesIds, language });
-        entriesMap = Object.fromEntries(entries.map((m) => [m.id, m]));
+        for (const entry of entries) {
+            const slugPath = getEntrySlugPath(entry.slug);
+            const slug = getSlugFromEntryData(entry.data, slugPath);
+            if (slug)
+                slugMap[entry.id] = slug;
+        }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const resolveValues = (value, fields) => {
@@ -83,8 +99,7 @@ export async function resolveUrlFields(data, fields, language) {
                         extras.newTab = parsed.newTab;
                     }
                     if (parsedValWithRelation.success) {
-                        const entryData = entriesMap[parsedValWithRelation.data.id]?.data;
-                        const slug = entryData?.seo?.slug;
+                        const slug = slugMap[parsedValWithRelation.data.id];
                         if (slug) {
                             result[field.slug] = { url: slug, ...extras };
                             break;
@@ -102,7 +117,7 @@ export async function resolveUrlFields(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         // Find the object definition for this item based on its slug
@@ -117,6 +132,42 @@ export async function resolveUrlFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'array':
+                    if (field.of === 'url' && Array.isArray(val)) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        result[field.slug] = val.map((item) => {
+                            const parsedValWithRelation = urlFieldDataWithRelationSchema.safeParse(item);
+                            const parsedVal = urlFieldDataSchema.safeParse(item);
+                            const parsed = parsedValWithRelation.success
+                                ? parsedValWithRelation.data
+                                : parsedVal.success
+                                    ? parsedVal.data
+                                    : null;
+                            if (!parsed)
+                                return item;
+                            const extras = {};
+                            if (parsed.text) {
+                                extras.text = language ? parsed.text[language] : parsed.text;
+                            }
+                            if (parsed.newTab !== undefined) {
+                                extras.newTab = parsed.newTab;
+                            }
+                            if (parsedValWithRelation.success) {
+                                const slug = slugMap[parsedValWithRelation.data.id];
+                                if (slug) {
+                                    return { url: slug, ...extras };
+                                }
+                            }
+                            const resolvedUrl = language
+                                ? parsed.url[language]
+                                : parsed.url;
+                            return { url: resolvedUrl, ...extras };
+                        });
+                    }
+                    else {
+                        result[field.slug] = val;
+                    }
+                    break;
                 default:
                     result[field.slug] = val;
             }

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

@@ -0,0 +1,10 @@
+/**
+ * Get the dot-path to the slug field for a given collection/single slug.
+ * Falls back to 'seo.slug' if no slugField is configured.
+ */
+export declare function getEntrySlugPath(configSlug: string): string;
+/**
+ * Traverse a dot-path in entry data and return the slug value.
+ * Handles both plain strings and localized objects { lang: string }.
+ */
+export declare function getSlugFromEntryData(data: Record<string, unknown>, slugPath: string, language?: string): string | undefined;

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

@@ -0,0 +1,34 @@
+import { getCMS } from '../../cms.js';
+const DEFAULT_SLUG_PATH = 'seo.slug';
+/**
+ * Get the dot-path to the slug field for a given collection/single slug.
+ * Falls back to 'seo.slug' if no slugField is configured.
+ */
+export function getEntrySlugPath(configSlug) {
+    try {
+        const config = getCMS().getBySlug(configSlug);
+        return config.slugField || DEFAULT_SLUG_PATH;
+    }
+    catch {
+        return DEFAULT_SLUG_PATH;
+    }
+}
+/**
+ * Traverse a dot-path in entry data and return the slug value.
+ * Handles both plain strings and localized objects { lang: string }.
+ */
+export function getSlugFromEntryData(data, slugPath, language) {
+    const parts = slugPath.split('.');
+    let current = data;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    if (typeof current === 'string')
+        return current;
+    if (language && current != null && typeof current === 'object') {
+        return current[language];
+    }
+    return undefined;
+}

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

@@ -6,6 +6,8 @@ function getFieldTypeAsString(field) {
         case 'date':
         case 'datetime':
             return 'string';
+        case 'content':
+            return 'StructuredContentDoc';
         case 'radio':
             return field.options.map((opt) => `'${opt.value.trim()}'`).join(' | ');
         case 'image': {
@@ -39,11 +41,11 @@ function getFieldTypeAsString(field) {
 				slug: '${field.slug}';
 				data: {${field.fields.map((f) => `  ${f.slug}${f.required ? '' : '?'}: ${getFieldTypeAsString(f)}`).join(';\n')}};
 			}`;
-        case 'array':
+        case 'blocks':
             return `
 			(
 			${field.of
-                .map((f) => ` 
+                .map((f) => `
 				{
 					slug: '${f.slug}';
 					data: {${f.fields.map((f) => `  ${f.slug}${f.required ? '' : '?'}: ${getFieldTypeAsString(f)}`).join(';\n')}};
@@ -51,13 +53,22 @@ function getFieldTypeAsString(field) {
 			`)
                 .join(' | ')}
 			)[]`;
+        case 'array':
+            switch (field.of) {
+                case 'text':
+                    return field.localized ? 'Record<string, string>[]' : 'string[]';
+                case 'number':
+                    return 'number[]';
+                case 'url':
+                    return 'UrlFieldData[]';
+            }
         case 'slug':
             return 'string';
         case 'seo':
             return `{
-				slug?: string;
+				slug: string;
 				canonicalUrl?: string;
-				title?: string;
+				title: string;
 				description?: string;
 				ogImage?: string;
 				keywords?: string;

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

@@ -4,6 +4,7 @@ import { generateTsTypeFromFields } from './fields.js';
 import { generateTsTypeFromFormFields } from './formFields.js';
 import { generateZodSchemaStringFromFormFieldsAsString } from './formFieldSchemaToString.js';
 import { toPascalCase } from './utils.js';
+import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
 function createCmsRuntimeDir() {
     const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
     mkdirSync(cmsDir, { recursive: true });
@@ -19,7 +20,7 @@ function generateTypesStringForRecords(type, records) {
 			export interface ${toPascalCase(single.slug)} {
 				id: string;
 				slug: string;
-				data: ${generateTsTypeFromFields(single.fields)}
+				data: ${generateTsTypeFromFields(getFieldsFromConfig(single))}
 				publishedAt: Date | null;
 			};
 		`;
@@ -68,7 +69,7 @@ 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 } from 'includio-cms/types';\n\n`;
+    code += `import type { MediaFile, ImageFieldData, VideoFieldData, StructuredContentDoc } from 'includio-cms/types';\n\n`;
     if (config.singles && config.singles.length > 0) {
         code += generateTypesStringForRecords('single', Object.values(config.singles));
     }

package/dist/db-postgres/index.js

@@ -101,9 +101,11 @@ export function pg(config) {
                     options.type ? eq(schema.entriesTable.type, options.type) : undefined,
                     options.slug ? eq(schema.entriesTable.slug, options.slug) : undefined,
                     options.ids ? inArray(schema.entriesTable.id, options.ids) : undefined,
-                    options.onlyArchived
-                        ? sql `${schema.entriesTable.archivedAt} IS NOT NULL`
-                        : isNull(schema.entriesTable.archivedAt)
+                    options.includeArchived
+                        ? undefined
+                        : options.onlyArchived
+                            ? sql `${schema.entriesTable.archivedAt} IS NOT NULL`
+                            : isNull(schema.entriesTable.archivedAt)
                 ].filter(Boolean);
                 const allConditions = [...baseConditions];
                 if (allConditions.length > 0) {
@@ -127,9 +129,11 @@ export function pg(config) {
                 options.type ? eq(schema.entriesTable.type, options.type) : undefined,
                 options.slug ? eq(schema.entriesTable.slug, options.slug) : undefined,
                 options.ids ? inArray(schema.entriesTable.id, options.ids) : undefined,
-                options.onlyArchived
-                    ? sql `${schema.entriesTable.archivedAt} IS NOT NULL`
-                    : isNull(schema.entriesTable.archivedAt)
+                options.includeArchived
+                    ? undefined
+                    : options.onlyArchived
+                        ? sql `${schema.entriesTable.archivedAt} IS NOT NULL`
+                        : isNull(schema.entriesTable.archivedAt)
             ].filter(Boolean);
             const [result] = await db
                 .select({ count: count() })

package/dist/files-local/index.js

@@ -15,76 +15,138 @@ const ffmpegPath = process.env.FFMPEG_PATH || '/usr/bin/ffmpeg';
 const ffprobePath = process.env.FFPROBE_PATH || '/usr/bin/ffprobe';
 ffmpeg.setFfmpegPath(ffmpegPath);
 ffmpeg.setFfprobePath(ffprobePath);
-// Funkcja pomocnicza do przetwarzania wideo
-async function processVideo(filepath, filename) {
-    return new Promise((resolve) => {
-        const thumbnailFilename = `${filename}_thumb.jpg`;
-        const thumbnailUrl = `/uploads/${thumbnailFilename}`;
-        const posterFilename = `${filename}_poster.jpg`;
-        const posterUrl = `/uploads/${posterFilename}`;
-        ffmpeg(filepath)
-            .on('error', () => {
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        promise.then((val) => {
+            clearTimeout(timer);
+            resolve(val);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+function probeVideo(filepath) {
+    return new Promise((resolve, reject) => {
+        ffmpeg.ffprobe(filepath, (err, metadata) => {
+            if (err) {
+                reject(new Error(`ffprobe failed: ${err.message || err}`));
+                return;
+            }
+            const videoStream = metadata.streams.find((s) => s.codec_type === 'video');
+            const duration = metadata.format.duration ?? null;
             resolve({
-                width: null,
-                height: null,
-                duration: null,
-                thumbnailUrl: null,
-                posterUrl: null
-            });
-        })
-            .on('end', () => {
-            // Po wygenerowaniu thumbnaiła, generujemy poster (wyższa jakość)
-            ffmpeg(filepath)
-                .on('error', () => {
-                // Poster failed, continue with thumbnail only
-                ffmpeg.ffprobe(filepath, (err, metadata) => {
-                    if (err) {
-                        resolve({ width: null, height: null, duration: null, thumbnailUrl, posterUrl: null });
-                        return;
-                    }
-                    const videoStream = metadata.streams.find((s) => s.codec_type === 'video');
-                    const duration = metadata.format.duration || null;
-                    resolve({
-                        width: videoStream?.width || null,
-                        height: videoStream?.height || null,
-                        duration: duration ? Math.round(duration) : null,
-                        thumbnailUrl,
-                        posterUrl: null
-                    });
-                });
-            })
-                .on('end', () => {
-                ffmpeg.ffprobe(filepath, (err, metadata) => {
-                    if (err) {
-                        resolve({ width: null, height: null, duration: null, thumbnailUrl, posterUrl });
-                        return;
-                    }
-                    const videoStream = metadata.streams.find((s) => s.codec_type === 'video');
-                    const duration = metadata.format.duration || null;
-                    resolve({
-                        width: videoStream?.width || null,
-                        height: videoStream?.height || null,
-                        duration: duration ? Math.round(duration) : null,
-                        thumbnailUrl,
-                        posterUrl
-                    });
-                });
-            })
-                .screenshots({
-                timestamps: ['00:00:01'],
-                filename: posterFilename,
-                folder: fullDir,
-                size: '1280x?' // Poster: szerszy, proporcjonalny
+                width: videoStream?.width ?? null,
+                height: videoStream?.height ?? null,
+                duration: duration ? Math.round(duration * 100) / 100 : null
             });
-        })
+        });
+    });
+}
+function takeScreenshot(filepath, config) {
+    return new Promise((resolve, reject) => {
+        ffmpeg(filepath)
+            .on('error', (err) => reject(new Error(`Screenshot failed: ${err.message || err}`)))
+            .on('end', () => resolve())
             .screenshots({
-            timestamps: ['00:00:01'],
-            filename: thumbnailFilename,
-            folder: fullDir,
-            size: '320x240'
+            timestamps: [config.timestamp],
+            filename: config.filename,
+            folder: config.folder,
+            size: config.size
+        });
+    });
+}
+function getSafeTimestamp(duration) {
+    if (duration === null || duration <= 0)
+        return '00:00:00.000';
+    if (duration < 1)
+        return '00:00:00.000';
+    if (duration < 3) {
+        const t = duration * 0.1;
+        return formatTimestamp(t);
+    }
+    return formatTimestamp(Math.min(1, duration * 0.1));
+}
+function formatTimestamp(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = seconds % 60;
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${s.toFixed(3).padStart(6, '0')}`;
+}
+let ffmpegAvailable = null;
+async function checkFfmpegAvailable() {
+    if (ffmpegAvailable !== null)
+        return ffmpegAvailable;
+    return new Promise((resolve) => {
+        ffmpeg.ffprobe('/dev/null', (err) => {
+            if (err && (String(err).includes('ENOENT') || String(err).includes('spawn'))) {
+                console.warn('[video] ffmpeg/ffprobe not found — video thumbnails disabled');
+                ffmpegAvailable = false;
+            }
+            else {
+                ffmpegAvailable = true;
+            }
+            resolve(ffmpegAvailable);
         });
     });
 }
+async function processVideo(filepath, filename) {
+    if (!(await checkFfmpegAvailable())) {
+        console.warn(`[video] Skipping processing for ${filename}: ffmpeg not available`);
+        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
+    }
+    const thumbnailFilename = `${filename}_thumb.jpg`;
+    const thumbnailUrl = `/uploads/${thumbnailFilename}`;
+    const posterFilename = `${filename}_poster.jpg`;
+    const posterUrl = `/uploads/${posterFilename}`;
+    // 1. Probe — get metadata first
+    let probe;
+    try {
+        probe = await withTimeout(probeVideo(filepath), 10_000, 'ffprobe');
+    }
+    catch (err) {
+        console.warn(`[video] ffprobe failed for ${filename}:`, err);
+        return { width: null, height: null, duration: null, thumbnailUrl: null, posterUrl: null };
+    }
+    const timestamp = getSafeTimestamp(probe.duration);
+    // 2. Thumbnail (320px wide, maintain aspect ratio)
+    let finalThumbnailUrl = null;
+    try {
+        await withTimeout(takeScreenshot(filepath, {
+            timestamp,
+            filename: thumbnailFilename,
+            folder: fullDir,
+            size: '320x?'
+        }), 15_000, 'thumbnail');
+        finalThumbnailUrl = thumbnailUrl;
+    }
+    catch (err) {
+        console.warn(`[video] Thumbnail failed for ${filename}:`, err);
+    }
+    // 3. Poster (up to 1280px wide, no upscale)
+    let finalPosterUrl = null;
+    const posterWidth = Math.min(1280, probe.width ?? 1280);
+    try {
+        await withTimeout(takeScreenshot(filepath, {
+            timestamp,
+            filename: posterFilename,
+            folder: fullDir,
+            size: `${posterWidth}x?`
+        }), 15_000, 'poster');
+        finalPosterUrl = posterUrl;
+    }
+    catch (err) {
+        console.warn(`[video] Poster failed for ${filename}:`, err);
+    }
+    return {
+        width: probe.width,
+        height: probe.height,
+        duration: probe.duration ? Math.round(probe.duration) : null,
+        thumbnailUrl: finalThumbnailUrl,
+        posterUrl: finalPosterUrl
+    };
+}
 async function ensureDir(dir) {
     try {
         await mkdir(dir, { recursive: true });

package/dist/server/auth.d.ts

@@ -2,6 +2,11 @@ export declare const auth: import("better-auth", { with: { "resolution-mode": "r
     database: (options: import("better-auth", { with: { "resolution-mode": "require" } }).BetterAuthOptions) => import("better-auth/adapters/drizzle", { with: { "resolution-mode": "require" } }).DBAdapter<import("better-auth", { with: { "resolution-mode": "require" } }).BetterAuthOptions>;
     emailAndPassword: {
         enabled: true;
+        sendResetPassword({ user, url }: {
+            user: import("better-auth", { with: { "resolution-mode": "require" } }).User;
+            url: string;
+            token: string;
+        }, request: Request | undefined): Promise<void>;
     };
     plugins: [{
         id: "admin";

package/dist/server/auth.js

@@ -2,12 +2,23 @@ import { betterAuth } from 'better-auth';
 import { drizzleAdapter } from 'better-auth/adapters/drizzle';
 import { db } from './db/index.js';
 import { admin } from 'better-auth/plugins';
+import { getCMS } from '../core/cms.js';
+import { resetPasswordEmailTemplate } from '../admin/email/reset-password-template.js';
 export const auth = betterAuth({
     database: drizzleAdapter(db, {
         provider: 'pg'
     }),
     emailAndPassword: {
-        enabled: true
+        enabled: true,
+        async sendResetPassword({ user, url }, request) {
+            const emailAdapter = getCMS().emailAdapter;
+            if (!emailAdapter) {
+                throw new Error('Email adapter not configured');
+            }
+            const lang = request?.headers.get('Accept-Language')?.startsWith('pl') ? 'pl' : 'en';
+            const { subject, html } = resetPasswordEmailTemplate({ resetUrl: url, lang });
+            await emailAdapter.sendMail({ to: [user.email], subject, html });
+        }
     },
     plugins: [admin()]
 });