includio-cms 0.37.3 → 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, ctx.locale) : 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/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/paraglide/messages/_index.d.ts

@@ -1,3 +1,36 @@
-export * from "./hello_world.js";
-export * from "./login_hello.js";
-export * from "./login_please_login.js";
+export function hello_world(inputs: {
+    name: NonNullable<unknown>;
+}, options?: {
+    locale?: "en" | "pl";
+}): string;
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+*
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+declare function login_hello(inputs?: {}, options?: {
+    locale?: "en" | "pl";
+}): string;
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+*
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+declare function login_please_login(inputs?: {}, options?: {
+    locale?: "en" | "pl";
+}): string;
+export { login_hello as login.hello, login_please_login as login.please_login };

package/dist/paraglide/messages/_index.js

@@ -1,4 +1,72 @@
 /* eslint-disable */
-export * from './hello_world.js'
-export * from './login_hello.js'
-export * from './login_please_login.js'
+import { getLocale, trackMessageCall, experimentalMiddlewareLocaleSplitting, isServer } from "../runtime.js"
+import * as en from "./en.js"
+import * as pl from "./pl.js"
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{ name: NonNullable<unknown> }} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+export const hello_world = (inputs, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.hello_world(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("hello_world", locale)
+	if (locale === "en") return en.hello_world(inputs)
+	return pl.hello_world(inputs)
+};
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+const login_hello = (inputs = {}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.login_hello(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("login_hello", locale)
+	if (locale === "en") return en.login_hello(inputs)
+	return pl.login_hello(inputs)
+};
+export { login_hello as "login.hello" }
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{}} inputs
+* @param {{ locale?: "en" | "pl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+const login_please_login = (inputs = {}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.login_please_login(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("login_please_login", locale)
+	if (locale === "en") return en.login_please_login(inputs)
+	return pl.login_please_login(inputs)
+};
+export { login_please_login as "login.please_login" }

package/dist/paraglide/messages/en.d.ts

@@ -0,0 +1,5 @@
+export const hello_world: (inputs: {
+    name: NonNullable<unknown>;
+}) => string;
+export const login_hello: (inputs: {}) => string;
+export const login_please_login: (inputs: {}) => string;

package/dist/paraglide/messages/en.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+
+
+export const hello_world = /** @type {(inputs: { name: NonNullable<unknown> }) => string} */ (i) => {
+	return `Hello, ${i.name} from en!`
+};
+
+export const login_hello = /** @type {(inputs: {}) => string} */ () => {
+	return `Welcome back`
+};
+
+export const login_please_login = /** @type {(inputs: {}) => string} */ () => {
+	return `Login to your account`
+};

package/dist/paraglide/messages/pl.d.ts

@@ -0,0 +1,5 @@
+export const hello_world: (inputs: {
+    name: NonNullable<unknown>;
+}) => string;
+export const login_hello: (inputs: {}) => string;
+export const login_please_login: (inputs: {}) => string;

package/dist/paraglide/messages/pl.js

@@ -0,0 +1,14 @@
+/* eslint-disable */
+
+
+export const hello_world = /** @type {(inputs: { name: NonNullable<unknown> }) => string} */ (i) => {
+	return `Hello, ${i.name} from pl!`
+};
+
+export const login_hello = /** @type {(inputs: {}) => string} */ () => {
+	return `Witaj ponownie`
+};
+
+export const login_please_login = /** @type {(inputs: {}) => string} */ () => {
+	return `Zaloguj się na swoje konto`
+};

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.schema.d.ts

@@ -36,6 +36,10 @@ export declare const cmsConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         orderable: z.ZodOptional<z.ZodBoolean>;
         listColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaultPopulate: z.ZodOptional<z.ZodObject<{
+            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            depth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         slug: z.ZodString;
         sidebarIcon: z.ZodOptional<z.ZodString>;
         previewUrl: z.ZodOptional<z.ZodString>;
@@ -261,6 +265,10 @@ export declare const _internal: {
         }, z.core.$strip>>;
         orderable: z.ZodOptional<z.ZodBoolean>;
         listColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaultPopulate: z.ZodOptional<z.ZodObject<{
+            select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            depth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         slug: z.ZodString;
         sidebarIcon: z.ZodOptional<z.ZodString>;
         previewUrl: z.ZodOptional<z.ZodString>;
@@ -401,6 +409,10 @@ export declare const _internal: {
             }, z.core.$strip>>;
             orderable: z.ZodOptional<z.ZodBoolean>;
             listColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            defaultPopulate: z.ZodOptional<z.ZodObject<{
+                select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                depth: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
             slug: z.ZodString;
             sidebarIcon: z.ZodOptional<z.ZodString>;
             previewUrl: z.ZodOptional<z.ZodString>;