includio-cms 0.37.2 → 0.37.4

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

@@ -2,53 +2,73 @@ import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap
 import { getCMS } from '../../cms.js';
 import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
+import { resolveEffectivePopulate, narrowFields, narrowData, populateConfigKey } from './populateSelect.js';
+import { pickVersion as pickVersionBase, pickAndHydrateVersions } from '../entries/operations/versionResolve.js';
 /**
- * Version of a *related* entry to populate. Exported for tests.
- *
- * `draft` falls back to the published version: a related entry that has never been
- * drafted (only published versions) must still resolve, otherwise draft previews
- * silently drop every relation to `null` — see preview.remote.ts, which populates
- * form data with `status: 'draft'`.
+ * Wersja *populowanej relacji*: draft zawsze z fallbackiem na published — relacja,
+ * która nigdy nie była szkicowana (tylko published), musi się rozwiązać, inaczej
+ * podgląd szkicu cicho zeruje każdą relację (patrz preview.remote.ts). Eksport dla testów.
  */
 export function pickVersion(versions, status) {
-    const sorted = versions.slice().sort((a, b) => b.versionNumber - a.versionNumber);
-    const now = new Date();
-    const published = () => sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) ?? null;
-    switch (status) {
-        case 'published':
-            return published();
-        case 'draft':
-            return sorted.find((v) => v.publishedAt == null) ?? published();
-        case 'scheduled':
-            return sorted.find((v) => v.publishedAt != null && v.publishedAt > now) ?? null;
-    }
+    return pickVersionBase(versions, status, { draftFallback: true });
 }
 export async function resolveRelationFields(data, fields, ctx) {
-    const entriesIds = [];
-    const optedOutFields = new Set();
-    // Collect ids skipping fields opted out at top level (raw passthrough).
+    const cms = getCMS();
+    // key `${id}::${configKey}` — ten sam target pod różnymi configami populuje się osobno.
+    const configByKey = new Map();
+    /** Efektywny config dla pola relacji. `null` = denylist (surowe ID). */
+    const effForField = (field, topLevel) => {
+        const callOv = topLevel ? ctx.populate.fields?.[field.slug] : undefined;
+        if (callOv === false)
+            return null; // top-level denylist → raw passthrough
+        let collectionDefault;
+        try {
+            const target = cms.getBySlug(field.collection);
+            collectionDefault = target.defaultPopulate;
+        }
+        catch {
+            collectionDefault = undefined;
+        }
+        const cfg = resolveEffectivePopulate({
+            callOverride: callOv,
+            fieldPopulate: field.populate,
+            collectionDefault
+        });
+        const key = populateConfigKey(cfg);
+        configByKey.set(key, cfg);
+        return { cfg, key };
+    };
+    // Zbierz pary (id, configKey) do populacji.
+    const wanted = [];
+    const seenPair = new Set();
+    const addId = (id, key) => {
+        const pk = `${id}::${key}`;
+        if (seenPair.has(pk))
+            return;
+        seenPair.add(pk);
+        wanted.push({ id, key });
+    };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const collectIds = (value, fields, topLevel) => {
         for (const field of fields) {
             const val = value?.[field.slug];
             if (val == null)
                 continue;
-            if (topLevel && ctx.populate.fields?.[field.slug] === false) {
-                optedOutFields.add(field.slug);
-                continue;
-            }
             switch (field.type) {
                 case 'relation': {
+                    const eff = effForField(field, topLevel);
+                    if (!eff)
+                        break; // denylist → nie fetchuj
                     // Skip empty strings — an unset optional relation stores '' and must
                     // never reach the id query (Postgres rejects '' as uuid).
                     if (field.multiple && Array.isArray(val)) {
                         for (const id of val) {
                             if (typeof id === 'string' && id !== '')
-                                entriesIds.push(id);
+                                addId(id, eff.key);
                         }
                     }
                     else if (typeof val === 'string' && val !== '') {
-                        entriesIds.push(val);
+                        addId(val, eff.key);
                     }
                     break;
                 }
@@ -86,92 +106,94 @@ export async function resolveRelationFields(data, fields, ctx) {
         }
     };
     collectIds(data, fields, true);
-    if (entriesIds.length === 0)
+    if (wanted.length === 0)
         return data;
-    // Filter: don't fetch already-visited (cycle) or beyond maxDepth — those stay raw IDs
-    const overDepth = ctx.depth >= ctx.maxDepth;
-    const fetchableIds = overDepth
-        ? []
-        : [...new Set(entriesIds)].filter((id) => !ctx.visited.has(id));
-    const cms = getCMS();
-    // entriesMap: id → Entry (populated) | null (fetched but missing version/missing entry).
-    // Absent key = id was NOT fetched (cycle, max depth, top-level opt-out) → falls back to raw id.
+    // Fetchowalność per (id, config): cap głębokości per-pole + brak cyklu.
+    const fetchable = wanted.filter(({ id, key }) => {
+        if (ctx.visited.has(id))
+            return false;
+        const cfg = configByKey.get(key) ?? null;
+        const fieldMax = cfg?.depth != null ? ctx.depth + 1 + cfg.depth : ctx.maxDepth;
+        return ctx.depth < fieldMax;
+    });
+    // entriesMap: `${id}::${key}` → Entry (populated) | null (fetched but missing).
+    // Brak klucza = nie fetchowano (cykl / max depth / denylist) → fallback do raw id.
     const entriesMap = {};
-    if (fetchableIds.length > 0) {
-        const dbEntries = await cms.databaseAdapter.getEntries({ ids: fetchableIds });
-        const aliveDbEntries = dbEntries.filter((e) => e.archivedAt == null);
-        const aliveIds = new Set(aliveDbEntries.map((e) => e.id));
-        // Strict: missing entry / archived → null in nested
-        for (const id of fetchableIds) {
-            if (!aliveIds.has(id))
-                entriesMap[id] = null;
-        }
-        if (aliveDbEntries.length > 0) {
-            const versions = await cms.databaseAdapter.getEntryVersions({
-                entryIds: aliveDbEntries.map((e) => e.id),
-                lang: ctx.locale
-            });
-            const versionsByEntry = new Map();
-            for (const v of versions) {
-                const arr = versionsByEntry.get(v.entryId) ?? [];
-                arr.push(v);
-                versionsByEntry.set(v.entryId, arr);
+    const fetchIds = [...new Set(fetchable.map((p) => p.id))];
+    if (fetchIds.length > 0) {
+        const dbEntries = await cms.databaseAdapter.getEntries({ ids: fetchIds });
+        const aliveById = new Map(dbEntries.filter((e) => e.archivedAt == null).map((e) => [e.id, e]));
+        const versionMap = await pickAndHydrateVersions({
+            adapter: cms.databaseAdapter,
+            entryIds: [...aliveById.keys()],
+            lang: ctx.locale,
+            status: ctx.status,
+            draftFallback: true
+        });
+        // Lazy import to avoid static circular dep with populateEntry → resolveRelationFields
+        const { _populate } = await import('./populateEntry.js');
+        await Promise.all(fetchable.map(async ({ id, key }) => {
+            const mk = `${id}::${key}`;
+            const dbEntry = aliveById.get(id);
+            if (!dbEntry) {
+                entriesMap[mk] = null; // strict: missing / archived → null
+                return;
             }
-            // Lazy import to avoid static circular dep with populateEntry → resolveRelationFields
-            const { _populate } = await import('./populateEntry.js');
-            await Promise.all(aliveDbEntries.map(async (dbEntry) => {
-                const vs = versionsByEntry.get(dbEntry.id) ?? [];
-                const picked = pickVersion(vs, ctx.status);
-                if (!picked) {
-                    entriesMap[dbEntry.id] = null; // strict: missing version in locale → null
-                    return;
-                }
-                let config;
-                try {
-                    config = cms.getBySlug(dbEntry.slug);
-                }
-                catch {
-                    entriesMap[dbEntry.id] = null;
-                    return;
-                }
-                const nestedFields = getFieldsFromConfig(config);
-                const nestedCtx = {
-                    locale: ctx.locale,
-                    status: ctx.status,
-                    depth: ctx.depth + 1,
-                    maxDepth: ctx.maxDepth,
-                    visited: new Set([...ctx.visited, dbEntry.id]),
-                    populate: ctx.populate,
-                    entryId: dbEntry.id
+            const picked = versionMap.get(id);
+            if (!picked) {
+                entriesMap[mk] = null; // strict: missing version in locale → null
+                return;
+            }
+            let config;
+            try {
+                config = cms.getBySlug(dbEntry.slug);
+            }
+            catch {
+                entriesMap[mk] = null;
+                return;
+            }
+            const cfg = configByKey.get(key) ?? null;
+            const allFields = getFieldsFromConfig(config);
+            const nestedFields = cfg?.select ? narrowFields(allFields, cfg.select) : allFields;
+            const nestedData = cfg?.select ? narrowData(picked.data, cfg.select) : picked.data;
+            const nestedMaxDepth = cfg?.depth != null ? ctx.depth + 1 + cfg.depth : ctx.maxDepth;
+            const nestedCtx = {
+                locale: ctx.locale,
+                status: ctx.status,
+                depth: ctx.depth + 1,
+                maxDepth: nestedMaxDepth,
+                visited: new Set([...ctx.visited, dbEntry.id]),
+                populate: ctx.populate,
+                entryId: dbEntry.id
+            };
+            try {
+                const populated = await _populate(nestedData, nestedFields, nestedCtx);
+                const slugPath = getEntrySlugPath(dbEntry.slug);
+                const slugValue = getSlugFromEntryData(picked.data, slugPath, ctx.locale);
+                const _url = slugValue ? getEntryPath(dbEntry.slug, slugValue, ctx.locale) : undefined;
+                entriesMap[mk] = {
+                    _id: dbEntry.id,
+                    _slug: dbEntry.slug,
+                    _type: dbEntry.type,
+                    _publishedAt: picked.publishedAt,
+                    _url,
+                    ...(config.type === 'collection' && config.orderable
+                        ? { _sortOrder: dbEntry.sortOrder }
+                        : {}),
+                    ...populated
                 };
-                try {
-                    const populated = await _populate(picked.data, nestedFields, nestedCtx);
-                    const slugPath = getEntrySlugPath(dbEntry.slug);
-                    const slugValue = getSlugFromEntryData(picked.data, slugPath, ctx.locale);
-                    const _url = slugValue ? getEntryPath(dbEntry.slug, slugValue) : undefined;
-                    entriesMap[dbEntry.id] = {
-                        _id: dbEntry.id,
-                        _slug: dbEntry.slug,
-                        _type: dbEntry.type,
-                        _publishedAt: picked.publishedAt,
-                        _url,
-                        ...(config.type === 'collection' && config.orderable
-                            ? { _sortOrder: dbEntry.sortOrder }
-                            : {}),
-                        ...populated
-                    };
-                }
-                catch (error) {
-                    console.error(`[CMS] Failed to populate nested entry ${dbEntry.id} (${dbEntry.slug}):`, error);
-                }
-            }));
-        }
+            }
+            catch (error) {
+                console.error(`[CMS] Failed to populate nested entry ${dbEntry.id} (${dbEntry.slug}):`, error);
+            }
+        }));
     }
-    const resolveRefId = (id) => {
+    const resolveRefId = (id, key) => {
+        const mk = `${id}::${key}`;
         // Has key (even if value is null) → use mapped value (Entry | null)
-        if (Object.prototype.hasOwnProperty.call(entriesMap, id))
-            return entriesMap[id];
-        // Not fetched (cycle, max depth, top-level opt-out) → raw ID
+        if (Object.prototype.hasOwnProperty.call(entriesMap, mk))
+            return entriesMap[mk];
+        // Not fetched (cycle, max depth, denylist) → raw ID
         return id;
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -184,18 +206,18 @@ export async function resolveRelationFields(data, fields, ctx) {
                 result[field.slug] = val;
                 continue;
             }
-            // Per-field opt-out at top level → raw passthrough
-            if (topLevel && optedOutFields.has(field.slug)) {
-                result[field.slug] = val;
-                continue;
-            }
             switch (field.type) {
                 case 'relation': {
+                    const eff = effForField(field, topLevel);
+                    if (!eff) {
+                        result[field.slug] = val; // denylist → raw passthrough
+                        break;
+                    }
                     if (field.multiple && Array.isArray(val)) {
-                        result[field.slug] = val.map((id) => typeof id === 'string' ? resolveRefId(id) : id);
+                        result[field.slug] = val.map((id) => typeof id === 'string' ? resolveRefId(id, eff.key) : id);
                     }
                     else if (typeof val === 'string') {
-                        result[field.slug] = resolveRefId(val);
+                        result[field.slug] = resolveRefId(val, eff.key);
                     }
                     else {
                         result[field.slug] = val;

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

@@ -109,7 +109,7 @@ export async function resolveRichtextLinks(data, fields, ctx) {
         const slugPath = configSlug ? getEntrySlugPath(configSlug) : 'seo.slug';
         const slug = getSlugFromEntryData(rawData, slugPath, language);
         if (slug) {
-            slugMap[entryId] = configSlug ? getEntryPath(configSlug, slug) : slug;
+            slugMap[entryId] = configSlug ? getEntryPath(configSlug, slug, language) : slug;
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

@@ -130,7 +130,7 @@ export async function resolveUrlFields(data, fields, ctx) {
                 const slugPath = getEntrySlugPath(entry.slug);
                 const slug = getSlugFromEntryData(version.data, slugPath, language);
                 if (slug)
-                    slugMap[entry.id] = getEntryPath(entry.slug, slug);
+                    slugMap[entry.id] = getEntryPath(entry.slug, slug, language);
             }
         }
     }

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

@@ -1,5 +1,5 @@
 export { getSlugFromEntryData } from '../../fields/slugPath.js';
 /** Get dot-path to slug field for a collection. Falls back to 'seo.slug'. */
 export declare function getEntrySlugPath(configSlug: string): string;
-/** Build full entry path using collection's pathTemplate. */
-export declare function getEntryPath(configSlug: string, slug: string): string;
+/** Build full entry path using collection's pathTemplate, prefixed per locale. */
+export declare function getEntryPath(configSlug: string, slug: string, locale?: string): string;

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

@@ -1,5 +1,6 @@
 import { getCMS } from '../../cms.js';
 import { getSlugFromEntryData, resolveSlugPath, applyPathTemplate } from '../../fields/slugPath.js';
+import { pathPrefixFor } from '../../i18n/localeUrl.js';
 export { getSlugFromEntryData } from '../../fields/slugPath.js';
 /** Get dot-path to slug field for a collection. Falls back to 'seo.slug'. */
 export function getEntrySlugPath(configSlug) {
@@ -10,12 +11,19 @@ export function getEntrySlugPath(configSlug) {
         return resolveSlugPath(undefined);
     }
 }
-/** Build full entry path using collection's pathTemplate. */
-export function getEntryPath(configSlug, slug) {
+/** Build full entry path using collection's pathTemplate, prefixed per locale. */
+export function getEntryPath(configSlug, slug, locale) {
+    let prefix = '';
     try {
-        return applyPathTemplate(getCMS().getBySlug(configSlug).pathTemplate, slug);
+        prefix = pathPrefixFor(getCMS().localeUrl, locale);
     }
     catch {
-        return applyPathTemplate(undefined, slug);
+        prefix = '';
+    }
+    try {
+        return applyPathTemplate(getCMS().getBySlug(configSlug).pathTemplate, slug, prefix);
+    }
+    catch {
+        return applyPathTemplate(undefined, slug, prefix);
     }
 }

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

@@ -5,6 +5,8 @@ import { generateTsTypeFromFormFields } from './formFields.js';
 import { generateZodSchemaStringFromFormFieldsAsString } from './formFieldSchemaToString.js';
 import { toPascalCase, quoteKey } from './utils.js';
 import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
+import { buildLocaleUrl } from '../../i18n/localeUrl.js';
+import { languageCode } from '../../../types/languages.js';
 function createCmsRuntimeDir() {
     const cmsDir = join(process.cwd(), 'src/lib/cms/runtime');
     mkdirSync(cmsDir, { recursive: true });
@@ -171,7 +173,7 @@ function generateTypes(config) {
             }
         }
     }
-    code += `\n export type SiteLanguage =  ${config.languages.map((lang) => JSON.stringify(lang)).join(' | ')};\n\n`;
+    code += `\n export type SiteLanguage =  ${config.languages.map((lang) => JSON.stringify(languageCode(lang))).join(' | ')};\n\n`;
     writeIfChanged(filePath, code);
 }
 function generateAPI(config) {
@@ -307,6 +309,62 @@ function generateRemote(config) {
     });
     writeIfChanged(filePath, code);
 }
+/**
+ * Emituje konfigurację app-owego Paraglide z `cms.config.languages` — jedno źródło prawdy i18n.
+ * `project.inlang/settings.json` (baseLocale=default, locales) + `src/lib/cms/runtime/i18n.ts`
+ * (`paraglideUrlPatterns` do vite.config + `reroute` do hooks). Konsument importuje te artefakty
+ * zamiast utrzymywać osobny, ręcznie synchronizowany config.
+ */
+function generateI18n(config) {
+    const lu = buildLocaleUrl(config.languages);
+    const codes = config.languages.map((l) => typeof l === 'string' ? l : l.code);
+    // 1) project.inlang/settings.json
+    const settings = {
+        $schema: 'https://inlang.com/schema/project-settings',
+        modules: [
+            'https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@4/dist/index.js',
+            'https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@2/dist/index.js'
+        ],
+        'plugin.inlang.messageFormat': { pathPattern: './messages/{locale}.json' },
+        baseLocale: lu.defaultLocale,
+        locales: codes
+    };
+    const inlangDir = join(process.cwd(), 'project.inlang');
+    mkdirSync(inlangDir, { recursive: true });
+    writeIfChanged(join(inlangDir, 'settings.json'), JSON.stringify(settings, null, '\t') + '\n');
+    createCmsRuntimeDir();
+    // 2) src/lib/cms/runtime/i18n.ts — CZYSTE dane urlPatterns (bez importów paraglide),
+    // żeby dało się importować w vite.config.ts (paraglide runtime jeszcze nie istnieje przy config-load).
+    // KOLEJNOŚĆ: prefiksowane locale NAJPIERW, domyślny (catch-all `/:path`) OSTATNI — inaczej
+    // catch-all złapałby `/en/...` przed wzorcem `/en`.
+    const ordered = [...codes].sort((a, b) => {
+        const aDef = a === lu.defaultLocale ? 1 : 0;
+        const bDef = b === lu.defaultLocale ? 1 : 0;
+        return aDef - bDef;
+    });
+    const localized = ordered
+        .map((c) => {
+        const e = lu.byCode[c];
+        const p = e && e.strategy === 'pathPrefix' ? e.pathPrefix : '';
+        return `\t\t\t['${c}', '${p}/:path(.*)?']`;
+    })
+        .join(',\n');
+    // Buduj specyfikator `$lib/...` przez konkatenację — inaczej svelte-package (build rdzenia)
+    // potraktuje literał jak import w tym pliku i przepisze go na relatywną ścieżkę RDZENIA.
+    const paraglideRuntime = '$' + 'lib/paraglide/runtime';
+    const i18n = `// AUTOGENEROWANE przez includio-cms (generateRuntime). Nie edytuj ręcznie.\n` +
+        `// \`import type\` jest wymazywany przy buildzie → można importować w vite.config.ts bez cyklu runtime.\n` +
+        `import type { Locale } from '${paraglideRuntime}';\n\n` +
+        `export const paraglideUrlPatterns: Array<{ pattern: string; localized: Array<[Locale, string]> }> = [\n` +
+        `\t{\n\t\tpattern: '/:path(.*)?',\n\t\tlocalized: [\n${localized}\n\t\t]\n\t}\n];\n`;
+    writeIfChanged(join(process.cwd(), 'src/lib/cms/runtime/i18n.ts'), i18n);
+    // 3) src/lib/cms/runtime/reroute.ts — reroute (importuje paraglide runtime), do wpięcia w hooks.ts
+    const reroute = `// AUTOGENEROWANE przez includio-cms (generateRuntime). Nie edytuj ręcznie.\n` +
+        `import { deLocalizeUrl } from '${paraglideRuntime}';\n` +
+        `import type { Reroute } from '@sveltejs/kit';\n\n` +
+        `export const reroute: Reroute = (request) => deLocalizeUrl(request.url).pathname;\n`;
+    writeIfChanged(join(process.cwd(), 'src/lib/cms/runtime/reroute.ts'), reroute);
+}
 export function generateRuntime(config) {
     // Build custom fields map from plugins for type generation
     const customFields = new Map();
@@ -325,4 +383,5 @@ export function generateRuntime(config) {
     generateSchemas(config);
     generateDrizzleSchema(config);
     generateRemote(config);
+    generateI18n(config);
 }

package/dist/db-postgres/index.js

@@ -494,6 +494,54 @@ export function pg(config) {
             }
             return await query;
         },
+        getEntryVersionsMeta: async (options) => {
+            const cols = {
+                id: schema.entryVersionsTable.id,
+                entryId: schema.entryVersionsTable.entryId,
+                lang: schema.entryVersionsTable.lang,
+                versionNumber: schema.entryVersionsTable.versionNumber,
+                createdAt: schema.entryVersionsTable.createdAt,
+                createdBy: schema.entryVersionsTable.createdBy,
+                publishedAt: schema.entryVersionsTable.publishedAt,
+                publishedBy: schema.entryVersionsTable.publishedBy
+            };
+            const query = db.select(cols).from(schema.entryVersionsTable);
+            if (options) {
+                const baseConditions = [
+                    options.entryIds
+                        ? inArray(schema.entryVersionsTable.entryId, options.entryIds)
+                        : undefined,
+                    options.ids ? inArray(schema.entryVersionsTable.id, options.ids) : undefined,
+                    options.lang ? eq(schema.entryVersionsTable.lang, options.lang) : undefined
+                ].filter(Boolean);
+                const jsonConditions = options.dataValues ? buildJsonConditions(options.dataValues) : [];
+                const jsonLikeConditions = options.dataLike
+                    ? buildJsonLikeConditions(options.dataLike)
+                    : [];
+                const jsonILikeOrCondition = options.dataILikeOr
+                    ? buildJsonILikeOrConditions(options.dataILikeOr)
+                    : undefined;
+                const allConditions = [
+                    ...baseConditions,
+                    ...jsonConditions,
+                    ...jsonLikeConditions,
+                    ...(jsonILikeOrCondition ? [jsonILikeOrCondition] : [])
+                ];
+                if (allConditions.length > 0) {
+                    query.where(and(...allConditions));
+                }
+            }
+            return await query;
+        },
+        getEntryVersionData: async ({ picks, lang }) => {
+            if (picks.length === 0)
+                return [];
+            const pairConds = picks.map((p) => and(eq(schema.entryVersionsTable.entryId, p.entryId), eq(schema.entryVersionsTable.versionNumber, p.versionNumber)));
+            return await db
+                .select()
+                .from(schema.entryVersionsTable)
+                .where(and(eq(schema.entryVersionsTable.lang, lang), or(...pairConds)));
+        },
         updateEntryVersion: async ({ id, data }) => {
             return db.transaction(async (tx) => {
                 const [result] = await tx

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

@@ -1,4 +1,4 @@
-import { integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { index, integer, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
 export const entriesTable = pgTable('entry', {
     id: uuid('id').primaryKey().defaultRandom(),
     slug: text('slug').notNull(),
@@ -9,4 +9,4 @@ export const entriesTable = pgTable('entry', {
     archivedAt: timestamp('archived_at'), // soft delete / archiwum
     // Manual ordering
     sortOrder: integer('sort_order')
-});
+}, (t) => [index('entry_slug_idx').on(t.slug), index('entry_type_idx').on(t.type)]);

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

@@ -1,4 +1,4 @@
-import { integer, jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { index, integer, jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
 import { entriesTable } from './entry.js';
 import {} from '../../types/entries.js';
 export const entryVersionsTable = pgTable('entry_version', {
@@ -13,4 +13,7 @@ export const entryVersionsTable = pgTable('entry_version', {
     createdBy: text('created_by'),
     publishedAt: timestamp('published_at'),
     publishedBy: text('published_by')
-});
+}, (t) => [
+    index('entry_version_entry_lang_ver_idx').on(t.entryId, t.lang, t.versionNumber),
+    index('entry_version_entry_published_idx').on(t.entryId, t.publishedAt)
+]);

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

@@ -1,4 +1,4 @@
-import { pgTable, primaryKey, uuid } from 'drizzle-orm/pg-core';
+import { index, pgTable, primaryKey, uuid } from 'drizzle-orm/pg-core';
 import { mediaFilesTable } from './mediaFile.js';
 import { mediaTagsTable } from './mediaTag.js';
 export const mediaFileTagsTable = pgTable('media_file_tag', {
@@ -8,4 +8,6 @@ export const mediaFileTagsTable = pgTable('media_file_tag', {
     tagId: uuid('tag_id')
         .notNull()
         .references(() => mediaTagsTable.id, { onDelete: 'cascade' })
-}, (t) => [primaryKey({ columns: [t.fileId, t.tagId] })]);
+}, 
+// PK (file_id, tag_id) już pokrywa lookup po file_id; brakuje leading tag_id.
+(t) => [primaryKey({ columns: [t.fileId, t.tagId] }), index('media_file_tag_tag_idx').on(t.tagId)]);

package/dist/sveltekit/server/handle.js

@@ -7,7 +7,8 @@ import { building } from '$app/environment';
 import { csrfGuard } from '../../server/security/csrf.js';
 import { rateLimitGuard } from '../../server/security/rate-limit.js';
 import { buildCspHeader } from '../../server/security/csp.js';
-import { baseLocale, extractLocaleFromRequest, isLocale } from '../../paraglide/runtime.js';
+import { baseLocale } from '../../paraglide/runtime.js';
+import { localeFromPath } from '../../core/i18n/localeUrl.js';
 const adminGuard = async ({ event, resolve }) => {
     const { user, session } = event.locals;
     // Secure the admin routes
@@ -62,12 +63,11 @@ const handleAuth = async ({ event, resolve }) => {
     return svelteKitHandler({ event, resolve, auth, building });
 };
 const paraglideLang = async ({ event, resolve }) => {
+    // Locale storefrontu z URL (prefiks z cms.config.languages), config-driven, bez cookie.
+    // Trasy bez prefiksu (np. /admin) → defaultLocale.
     let locale = baseLocale;
     try {
-        const detected = extractLocaleFromRequest(event.request);
-        if (detected && isLocale(detected)) {
-            locale = detected;
-        }
+        locale = localeFromPath(getCMS().localeUrl, event.url.pathname);
     }
     catch {
         // fall back to baseLocale

package/dist/types/adapters/db.d.ts

@@ -1,5 +1,5 @@
 import type { ConsentLogData, ConsentLogRecord, GetConsentLogsFilters } from '../consent.js';
-import type { DbEntry, DbEntryInsert, DbEntryVersion, DbEntryVersionInsert, GetDbEntriesOptions, GetDbEntryVersionsOptions, GetPaginatedEntriesOptions, PaginatedEntryRow, PaginationOptions } from '../entries.js';
+import type { DbEntry, DbEntryInsert, DbEntryVersion, DbEntryVersionInsert, DbEntryVersionMeta, GetDbEntriesOptions, GetDbEntryVersionsOptions, GetPaginatedEntriesOptions, PaginatedEntryRow, PaginationOptions } from '../entries.js';
 import type { ImageFieldStyle } from '../fields.js';
 import type { FormSubmission } from '../forms.js';
 import type { ImageStyle, MediaFile, MediaTag, UploadedMediaFile, VideoStyle, VideoStyleStatus } from '../media.js';
@@ -23,6 +23,10 @@ export interface DatabaseAdapter {
     createEntryVersion: CreateEntryVersion;
     updateEntryVersion: UpdateEntryVersion;
     getEntryVersions: GetEntryVersions;
+    /** Metadane wersji bez blobu `data` — do wyboru najnowszej wersji bez over-fetchu. */
+    getEntryVersionsMeta: GetEntryVersionsMeta;
+    /** Hydratacja `data` tylko dla wybranych par (entryId, versionNumber). */
+    getEntryVersionData: GetEntryVersionData;
     deleteEntryVersion: DeleteEntryVersion;
     createFormSubmission: CreateFormSubmission;
     getFormSubmissions: GetFormSubmissions;
@@ -88,6 +92,14 @@ export type ArchiveEntry = (data: {
 }) => Promise<DbEntry>;
 export type CreateEntryVersion = (data: DbEntryVersionInsert) => Promise<DbEntryVersion>;
 export type GetEntryVersions = (data: GetDbEntryVersionsOptions) => Promise<DbEntryVersion[]>;
+export type GetEntryVersionsMeta = (data: GetDbEntryVersionsOptions) => Promise<DbEntryVersionMeta[]>;
+export type GetEntryVersionData = (data: {
+    picks: {
+        entryId: string;
+        versionNumber: number;
+    }[];
+    lang: string;
+}) => Promise<DbEntryVersion[]>;
 export type UpdateEntryVersion = (data: {
     id: string;
     data: Partial<DbEntryVersion>;

package/dist/types/cms.d.ts

@@ -1,7 +1,7 @@
 import type { DatabaseAdapter } from './adapters/db.js';
 import type { FilesAdapter } from './adapters/files.js';
 import type { CollectionConfig, CollectionConfigWithType } from './collections.js';
-import type { Language } from './languages.js';
+import type { Language, LanguageEntry } from './languages.js';
 import type { SingleConfig, SingleConfigWithType } from './singles.js';
 import type { CustomFieldDefinition, IconSetPlugin, Plugin } from './plugins.js';
 import type { FormConfig } from './forms.js';
@@ -144,7 +144,8 @@ export interface AdminConfig {
     extraNavItems?: import('../admin/types.js').AdminNavItem[];
 }
 export interface CMSConfig {
-    languages: Language[];
+    /** Kod ISO albo obiekt `{ code, default?, url? }`. Znormalizowane do kodów w `CMS.languages`. */
+    languages: LanguageEntry[];
     collections?: CollectionConfig[];
     singles?: SingleConfig[];
     forms?: FormConfig[];