includio-cms 0.24.1 → 0.26.0

package/dist/core/fields/resolveSeo.js

@@ -0,0 +1,88 @@
+const SEO_KEYS = [
+    'slug',
+    'canonicalUrl',
+    'title',
+    'description',
+    'ogImage',
+    'keywords',
+    'customCode'
+];
+// Compile-time exhaustiveness guard: fails the build if `SeoFieldData` gains or
+// loses a key relative to `SEO_KEYS`, instead of a key silently dropping from
+// the resolver. Must reference every `SeoFieldData` key and compile today.
+const _SEO_KEYS_EXHAUSTIVE = {
+    slug: true,
+    canonicalUrl: true,
+    title: true,
+    description: true,
+    ogImage: true,
+    keywords: true,
+    customCode: true
+};
+void _SEO_KEYS_EXHAUSTIVE;
+/**
+ * Resolve `entry.seo` into flat fields, flattening localized objects by
+ * `language`.
+ *
+ * For each of the six text keys: a `string` value passes through; a localized
+ * `{ lang: string }` object resolves to `obj[language]` (or `undefined` if the
+ * requested language is missing); anything else resolves to `undefined`.
+ *
+ * `ogImage` is exempt from flattening: it passes through unchanged as a string
+ * or a {@link MediaFile} object (only `null`/`undefined` → `undefined`).
+ *
+ * The name `resolveSeo` is a deliberate, v1.0-frozen choice — it aligns with
+ * the `resolveEntryUrl` / `resolveMedia*` resolver family.
+ *
+ * @param entry - The (possibly resolved/hydrated) entry, or any object with an
+ * optional `seo` property. A non-object or missing `seo` yields all-`undefined`.
+ * @param language - The active language code. Required to flatten localized
+ * `{ lang: string }` values; localized fields resolve to `undefined` without it.
+ * @returns A {@link ResolvedSeo} — all keys present, each `string`/`MediaFile`
+ * (only `ogImage`) or `undefined`.
+ * @public
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { resolveSeo } from 'includio-cms/core';
+ *   import { Seo } from 'includio-cms';
+ *   let { entry, language } = $props();
+ *   const seo = $derived(resolveSeo(entry, language));
+ * </script>
+ *
+ * <svelte:head>
+ *   {#if seo.title}<title>{seo.title}</title>{/if}
+ *   {#if seo.canonicalUrl}<link rel="canonical" href={seo.canonicalUrl} />{/if}
+ * </svelte:head>
+ *
+ * <Seo
+ *   title={seo.title}
+ *   description={seo.description}
+ *   keywords={seo.keywords}
+ *   ogImage={seo.ogImage}
+ *   canonicalUrl={seo.canonicalUrl}
+ * />
+ * ```
+ */
+export function resolveSeo(entry, language) {
+    const rawSeo = entry.seo;
+    const seo = rawSeo != null && typeof rawSeo === 'object' ? rawSeo : {};
+    const out = {};
+    for (const k of SEO_KEYS) {
+        const v = seo[k];
+        if (k === 'ogImage') {
+            // Never localize/flatten: pass string OR MediaFile object through.
+            out[k] = v != null && (typeof v === 'string' || typeof v === 'object') ? v : undefined;
+        }
+        else if (typeof v === 'string') {
+            out[k] = v;
+        }
+        else if (language && v != null && typeof v === 'object') {
+            out[k] = v[language];
+        }
+        else {
+            out[k] = undefined;
+        }
+    }
+    return out;
+}

package/dist/core/fields/seoFieldDescriptor.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * @internal v1.0-frozen SEO field shape. SSOT for Zod + TS gen. Mismatches
+ * (description/ogImage required-in-Zod vs optional-in-TS; ogImage flat-not-localized)
+ * are PRE-EXISTING and preserved 1:1. Fixing = behavior change, post-1.0.
+ *
+ * NOTE: the current Zod `z.object` key order and the current TS template-literal
+ * line order DIFFER (Zod: ...keywords, ogImage, customCode; TS: ...ogImage,
+ * keywords, customCode). This array uses the ZOD source order; `buildSeoTsType`
+ * keeps its own (TS) line order verbatim and only derives `?` per key from
+ * `tsOptional`. The Zod shape-keys snapshot sorts keys; the TS-type-string
+ * snapshot preserves line order verbatim — so both orderings are deliberately
+ * reproduced 1:1.
+ */
+export interface SeoDescriptorEntry {
+    key: string;
+    /** non-localized Zod */
+    zod: 'string' | 'string-optional';
+    zodLocalized: 'perLang-string' | 'perLang-optional' | 'flat-string';
+    /** TS codegen */
+    tsOptional: boolean;
+}
+export declare const SEO_FIELD_DESCRIPTOR: readonly SeoDescriptorEntry[];
+/**
+ * @internal Builds the exact object passed to `z.object(...)` for the SEO field,
+ * for both non-localized and localized modes — byte-identical to the previous
+ * hand-written blocks in `fieldSchemaToTs.ts`.
+ */
+export declare function buildSeoZodShape(languages: string[], localized: boolean): Record<string, z.ZodType>;
+/**
+ * @internal TS-codegen line order (verbatim from generator/fields.ts
+ * `case 'seo':`). Distinct from the Zod object key order above (see module
+ * note). Exported solely so drift-guard tests can assert it stays a
+ * permutation of the descriptor keys.
+ */
+export declare const SEO_TS_LINE_ORDER: readonly ["slug", "canonicalUrl", "title", "description", "ogImage", "keywords", "customCode"];
+/**
+ * @internal Returns the SEO TS type string with EXACTLY the same characters
+ * (tabs/braces/whitespace) as the previous hand-written template literal in
+ * `server/generator/fields.ts`. Only the per-key `?` is derived from the
+ * descriptor's `tsOptional`.
+ */
+export declare function buildSeoTsType(): string;

package/dist/core/fields/seoFieldDescriptor.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+export const SEO_FIELD_DESCRIPTOR = [
+    { key: 'slug', zod: 'string', zodLocalized: 'perLang-string', tsOptional: false },
+    {
+        key: 'canonicalUrl',
+        zod: 'string-optional',
+        zodLocalized: 'perLang-optional',
+        tsOptional: true
+    },
+    { key: 'title', zod: 'string', zodLocalized: 'perLang-string', tsOptional: false },
+    { key: 'description', zod: 'string', zodLocalized: 'perLang-string', tsOptional: true },
+    { key: 'keywords', zod: 'string-optional', zodLocalized: 'perLang-optional', tsOptional: true },
+    { key: 'ogImage', zod: 'string', zodLocalized: 'flat-string', tsOptional: true },
+    { key: 'customCode', zod: 'string-optional', zodLocalized: 'perLang-optional', tsOptional: true }
+];
+/**
+ * @internal Builds the exact object passed to `z.object(...)` for the SEO field,
+ * for both non-localized and localized modes — byte-identical to the previous
+ * hand-written blocks in `fieldSchemaToTs.ts`.
+ */
+export function buildSeoZodShape(languages, localized) {
+    const shape = {};
+    for (const entry of SEO_FIELD_DESCRIPTOR) {
+        if (!localized) {
+            shape[entry.key] = entry.zod === 'string-optional' ? z.string().optional() : z.string();
+            continue;
+        }
+        switch (entry.zodLocalized) {
+            case 'flat-string':
+                shape[entry.key] = z.string();
+                break;
+            case 'perLang-optional':
+                shape[entry.key] = z.object(Object.fromEntries(languages.map((lang) => [lang, z.string().optional()])));
+                break;
+            case 'perLang-string':
+                shape[entry.key] = z.object(Object.fromEntries(languages.map((lang) => [lang, z.string()])));
+                break;
+            default: {
+                const _exhaustive = entry.zodLocalized;
+                throw new Error(`Unhandled zodLocalized: ${String(_exhaustive)}`);
+            }
+        }
+    }
+    return shape;
+}
+/**
+ * @internal TS-codegen line order (verbatim from generator/fields.ts
+ * `case 'seo':`). Distinct from the Zod object key order above (see module
+ * note). Exported solely so drift-guard tests can assert it stays a
+ * permutation of the descriptor keys.
+ */
+export const SEO_TS_LINE_ORDER = [
+    'slug',
+    'canonicalUrl',
+    'title',
+    'description',
+    'ogImage',
+    'keywords',
+    'customCode'
+];
+/**
+ * @internal Returns the SEO TS type string with EXACTLY the same characters
+ * (tabs/braces/whitespace) as the previous hand-written template literal in
+ * `server/generator/fields.ts`. Only the per-key `?` is derived from the
+ * descriptor's `tsOptional`.
+ */
+export function buildSeoTsType() {
+    const byKey = new Map(SEO_FIELD_DESCRIPTOR.map((e) => [e.key, e]));
+    const lines = SEO_TS_LINE_ORDER.map((key) => {
+        const entry = byKey.get(key);
+        return `\t\t\t\t${key}${entry.tsOptional ? '?' : ''}: string;`;
+    });
+    return `{\n${lines.join('\n')}\n\t\t\t}`;
+}

package/dist/core/fields/slugPath.d.ts

@@ -0,0 +1,13 @@
+/** @internal Pure: resolve slug dot-path, defaulting to 'seo.slug'. */
+export declare function resolveSlugPath(slugField: string | undefined): string;
+/** @internal Traverse dot-path; handles string & localized { lang: string }. */
+export declare function getSlugFromEntryData(data: Record<string, unknown>, slugPath: string, language?: string): string | undefined;
+/** @internal Pure: apply pathTemplate (no getCMS). */
+export declare function applyPathTemplate(pathTemplate: string | undefined, slug: string): string;
+/** @internal Compose full entry URL; undefined when no resolvable slug. */
+export declare function resolveEntryUrl(opts: {
+    slugField?: string;
+    pathTemplate?: string;
+    data: Record<string, unknown>;
+    language?: string;
+}): string | undefined;

package/dist/core/fields/slugPath.js

@@ -0,0 +1,32 @@
+const DEFAULT_SLUG_PATH = 'seo.slug';
+/** @internal Pure: resolve slug dot-path, defaulting to 'seo.slug'. */
+export function resolveSlugPath(slugField) {
+    return slugField || DEFAULT_SLUG_PATH;
+}
+/** @internal Traverse dot-path; handles string & localized { 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;
+}
+/** @internal Pure: apply pathTemplate (no getCMS). */
+export function applyPathTemplate(pathTemplate, slug) {
+    return pathTemplate ? pathTemplate.replace('{slug}', slug) : slug;
+}
+/** @internal Compose full entry URL; undefined when no resolvable slug. */
+export function resolveEntryUrl(opts) {
+    const slug = getSlugFromEntryData(opts.data, resolveSlugPath(opts.slugField), opts.language);
+    if (!slug)
+        return undefined;
+    return applyPathTemplate(opts.pathTemplate, slug);
+}

package/dist/core/fields/urlUtils.d.ts

@@ -2,6 +2,14 @@
  * Check if URL is external (starts with http:// or https://).
  */
 export declare function isExternalUrl(url: string): boolean;
+/**
+ * Validate a URL field string value. Empty is valid (presence is enforced by
+ * `required`). Accepts absolute http(s) URLs, `mailto:` / `tel:`, and any
+ * scheme-less value (root-relative `/path`, anchor `#id`, or a bare internal
+ * slug like `witaj` — many non-technical editors omit the leading slash).
+ * Rejects whitespace and disallowed schemes (e.g. `javascript:`).
+ */
+export declare function isValidUrlValue(value: string): boolean;
 /**
  * Build rel attribute string from individual tokens.
  * Deduplicates and returns space-separated string or empty string.

package/dist/core/fields/urlUtils.js

@@ -4,6 +4,33 @@
 export function isExternalUrl(url) {
     return /^https?:\/\//i.test(url);
 }
+/**
+ * Validate a URL field string value. Empty is valid (presence is enforced by
+ * `required`). Accepts absolute http(s) URLs, `mailto:` / `tel:`, and any
+ * scheme-less value (root-relative `/path`, anchor `#id`, or a bare internal
+ * slug like `witaj` — many non-technical editors omit the leading slash).
+ * Rejects whitespace and disallowed schemes (e.g. `javascript:`).
+ */
+export function isValidUrlValue(value) {
+    const v = value.trim();
+    if (v === '')
+        return true;
+    if (/\s/.test(value))
+        return false;
+    const schemeMatch = v.match(/^([a-z][a-z0-9+.-]*):/i);
+    if (!schemeMatch)
+        return true; // scheme-less → internal path/slug/anchor
+    const scheme = schemeMatch[1].toLowerCase();
+    if (scheme === 'mailto' || scheme === 'tel')
+        return true;
+    try {
+        const u = new URL(v);
+        return u.protocol === 'http:' || u.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Build rel attribute string from individual tokens.
  * Deduplicates and returns space-separated string or empty string.

package/dist/core/index.d.ts

@@ -1,4 +1,5 @@
 export { getCMS } from './cms.js';
 export { resolveMediaWithStyles, type ResolvedMedia } from './server/fields/utils/resolveMedia.js';
+export { resolveSeo, type ResolvedSeo } from './fields/resolveSeo.js';
 export { createEntityAPI } from '../entity/index.js';
 export { getAuth } from '../server/auth.js';

package/dist/core/index.js

@@ -1,4 +1,5 @@
 export { getCMS } from './cms.js';
 export { resolveMediaWithStyles } from './server/fields/utils/resolveMedia.js';
+export { resolveSeo } from './fields/resolveSeo.js';
 export { createEntityAPI } from '../entity/index.js';
 export { getAuth } from '../server/auth.js';

package/dist/core/server/entries/operations/create.js

@@ -6,6 +6,7 @@ import { _getDbEntryOrThrow as getDbEntryOrThrow } from './get.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
 import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import { CmsError, formatZodDataIssues } from '../../../errors.js';
+import { assertSlugUnique } from './slugUniqueness.js';
 export const createEntrySchema = z.object({
     slug: z.string(),
     type: z.enum(entryTypes)
@@ -51,6 +52,18 @@ export const createEntryVersion = async (data, options) => {
         }
         validatedData = parsedData.data;
     }
+    // Slug uniqueness: only enforced for published-or-scheduled writes (draft
+    // versions and skipValidation paths — e.g. seeds — are exempt). Each slug
+    // field is checked in its own namespace (see assertSlugUnique).
+    if (data.publishedAt != null && !options?.skipValidation) {
+        const entry = await getDbEntryOrThrow({ id: data.entryId });
+        await assertSlugUnique({
+            collection: entry.slug,
+            lang: data.lang,
+            data: validatedData,
+            excludeEntryId: data.entryId
+        });
+    }
     const newEntryVersion = await getCMS().databaseAdapter.createEntryVersion({
         ...data,
         createdBy: user.id,

package/dist/core/server/entries/operations/get.d.ts

@@ -17,6 +17,13 @@ export declare const getEntryLabels: (options: {
     search?: string;
     limit?: number;
     status?: "published" | "draft" | "all";
+    /**
+     * Preferred language for entry titles. Falls back to other languages when
+     * an entry has no version in the preferred one (links are language-
+     * agnostic — we resolve by id, but the human label should follow the
+     * editor's content language).
+     */
+    language?: string;
 }) => Promise<{
     id: string;
     label: string;

package/dist/core/server/entries/operations/get.js

@@ -121,18 +121,22 @@ export const getEntryLabels = async (options) => {
     if (dbEntries.length === 0)
         return [];
     const entryIds = dbEntries.map((e) => e.id);
-    const language = cms.languages[0];
-    const allVersions = await cms.databaseAdapter.getEntryVersions({
-        entryIds,
-        lang: language
-    });
+    // Scan the preferred language first, then the rest as fallback. Without
+    // this an entry that only has a `pl` version was invisible to a `pl`
+    // editor because cms.languages[0] = 'en' in demo.
+    const langs = [
+        ...(options.language ? [options.language] : []),
+        ...cms.languages.filter((l) => l !== options.language)
+    ];
+    const allVersions = (await Promise.all(langs.map((lang) => cms.databaseAdapter.getEntryVersions({ entryIds, lang }).then((vs) => vs.map((v) => ({ ...v, _langOrder: langs.indexOf(lang) })))))).flat();
     const now = new Date();
     const statusFilter = options.status ?? 'all';
     const entryAdminTitle = config.entryAdminTitle;
     let results = dbEntries
         .map((entry) => {
         const entryVersions = allVersions.filter((v) => v.entryId === entry.id);
-        const sorted = entryVersions.sort((a, b) => b.versionNumber - a.versionNumber);
+        // Preferred language wins; within a language, the latest version.
+        const sorted = entryVersions.sort((a, b) => a._langOrder - b._langOrder || b.versionNumber - a.versionNumber);
         const publishedVersion = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
         const hasPublished = publishedVersion != null;
         if (statusFilter === 'published' && !hasPublished)

package/dist/core/server/entries/operations/slugUniqueness.d.ts

@@ -0,0 +1,37 @@
+import type { Field } from '../../../../types/fields.js';
+/**
+ * Collect every dot-path in a collection whose value should be unique across
+ * entries (per content language) when published.
+ *
+ * Rule (decision: per-path, not per-collection):
+ * - Each `SlugField` (root or nested inside an object) has its own namespace.
+ *   Two entries' top-level `slug` must not collide, but `slug` (entry A) and
+ *   `seo.slug` (entry B) MAY share a value — they identify different things.
+ * - A `SeoField` always contributes its own `<path>.slug` namespace.
+ *
+ * Recurses into `object` fields; skips `array`/`blocks` because identifiers
+ * inside repeatable items aren't entry-level slugs.
+ */
+export declare function collectSlugFieldPaths(fields: Field[], prefix?: string): string[];
+export interface AssertSlugUniqueArgs {
+    /** Collection slug (config slug, e.g. `'blog-post'`). */
+    collection: string;
+    /** Content language whose slugs must not collide. */
+    lang: string;
+    /** Validated entry data about to be persisted as a published version. */
+    data: Record<string, unknown>;
+    /** Entry being published — excluded from the conflict scan. */
+    excludeEntryId: string;
+}
+/**
+ * Reject publishing when any slug-typed field (or `seo.slug`) collides with
+ * another entry's currently-published-or-scheduled version in the same
+ * collection + language. Each slug path is checked in its own namespace.
+ * Drafts, archived entries, the entry's own history, and other languages
+ * are ignored. Empty slug values are skipped — uniqueness is only
+ * meaningful for non-empty strings.
+ *
+ * @throws CmsError SLUG_DUPLICATE on the first conflict (`details.path` says
+ *   which slug-field collided).
+ */
+export declare function assertSlugUnique({ collection, lang, data, excludeEntryId }: AssertSlugUniqueArgs): Promise<void>;

package/dist/core/server/entries/operations/slugUniqueness.js

@@ -0,0 +1,116 @@
+import { getCMS } from '../../../cms.js';
+import { CmsError } from '../../../errors.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
+/**
+ * Collect every dot-path in a collection whose value should be unique across
+ * entries (per content language) when published.
+ *
+ * Rule (decision: per-path, not per-collection):
+ * - Each `SlugField` (root or nested inside an object) has its own namespace.
+ *   Two entries' top-level `slug` must not collide, but `slug` (entry A) and
+ *   `seo.slug` (entry B) MAY share a value — they identify different things.
+ * - A `SeoField` always contributes its own `<path>.slug` namespace.
+ *
+ * Recurses into `object` fields; skips `array`/`blocks` because identifiers
+ * inside repeatable items aren't entry-level slugs.
+ */
+export function collectSlugFieldPaths(fields, prefix = '') {
+    const paths = [];
+    for (const f of fields) {
+        const full = prefix ? `${prefix}.${f.slug}` : f.slug;
+        if (f.type === 'slug') {
+            paths.push(full);
+        }
+        else if (f.type === 'seo') {
+            paths.push(`${full}.slug`);
+        }
+        else if (f.type === 'object' && 'fields' in f) {
+            paths.push(...collectSlugFieldPaths(f.fields, full));
+        }
+    }
+    return paths;
+}
+/** Traverse dot-path on a plain object; returns undefined if any segment missing. */
+function readDotPath(data, path) {
+    const parts = path.split('.');
+    let current = data;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/** Resolve a slug value at dot-path; handles raw string or `{ lang: string }`. */
+function readSlugAtPath(data, path, lang) {
+    const raw = readDotPath(data, path);
+    if (typeof raw === 'string')
+        return raw;
+    if (raw != null && typeof raw === 'object') {
+        return raw[lang];
+    }
+    return undefined;
+}
+/**
+ * Reject publishing when any slug-typed field (or `seo.slug`) collides with
+ * another entry's currently-published-or-scheduled version in the same
+ * collection + language. Each slug path is checked in its own namespace.
+ * Drafts, archived entries, the entry's own history, and other languages
+ * are ignored. Empty slug values are skipped — uniqueness is only
+ * meaningful for non-empty strings.
+ *
+ * @throws CmsError SLUG_DUPLICATE on the first conflict (`details.path` says
+ *   which slug-field collided).
+ */
+export async function assertSlugUnique({ collection, lang, data, excludeEntryId }) {
+    const cms = getCMS();
+    let config;
+    try {
+        config = cms.getBySlug(collection);
+    }
+    catch {
+        return; // unknown collection — nothing to check
+    }
+    const fields = getFieldsFromConfig(config);
+    const slugPaths = collectSlugFieldPaths(fields);
+    // Snapshot incoming values, dropping empty entries up-front so we don't
+    // fetch other entries' data when nothing could collide.
+    const incoming = slugPaths
+        .map((path) => ({ path, value: readSlugAtPath(data, path, lang) }))
+        .filter((p) => typeof p.value === 'string' && p.value.trim() !== '');
+    if (incoming.length === 0)
+        return;
+    const dbEntries = await cms.databaseAdapter.getEntries({ slug: collection });
+    const otherIds = dbEntries
+        .filter((e) => e.archivedAt == null && e.id !== excludeEntryId)
+        .map((e) => e.id);
+    if (otherIds.length === 0)
+        return;
+    const versions = await cms.databaseAdapter.getEntryVersions({
+        entryIds: otherIds,
+        lang
+    });
+    // Each other entry can have many historical versions — only its latest
+    // published-or-scheduled version is "live" for slug purposes, so collapse
+    // per entry before comparing.
+    const latestPerEntry = new Map();
+    for (const v of versions) {
+        if (v.publishedAt == null)
+            continue;
+        const cur = latestPerEntry.get(v.entryId);
+        if (!cur || v.versionNumber > cur.versionNumber) {
+            latestPerEntry.set(v.entryId, {
+                versionNumber: v.versionNumber,
+                data: v.data
+            });
+        }
+    }
+    for (const [entryId, version] of latestPerEntry) {
+        for (const { path, value } of incoming) {
+            const otherSlug = readSlugAtPath(version.data, path, lang);
+            if (otherSlug === value) {
+                throw new CmsError('SLUG_DUPLICATE', `Slug „${value}" jest już używany w innym wpisie tej kolekcji (pole „${path}", język: ${lang}).`, { collection, lang, path, slug: value, conflictEntryId: entryId });
+            }
+        }
+    }
+}

package/dist/core/server/entries/operations/update.d.ts

@@ -11,7 +11,7 @@ export declare const updateEntryVersionSchema: z.ZodObject<{
     publishedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 export declare const updateEntryVersion: (id: string, data: Partial<DbEntryVersion>) => Promise<DbEntryVersion>;
-export declare const updateEntryVersionCommandTypes: readonly ["draft", "published-now", "published-scheduled", "cancel-published"];
+export declare const updateEntryVersionCommandTypes: readonly ["draft", "published-now", "published-scheduled", "cancel-published", "cancel-scheduled"];
 export type UpdateEntryVersionCommandType = (typeof updateEntryVersionCommandTypes)[number];
 /** Prune old draft versions scoped to (entryId, lang) */
 export declare const pruneOldDraftVersions: (entryId: string, lang: string) => Promise<void>;
@@ -21,3 +21,8 @@ export declare const upsertDraftVersion: (entryId: string, data: Record<string,
 }) => Promise<DbEntryVersion>;
 /** Unpublish a specific language version for an entry */
 export declare const unpublishEntryLang: (entryId: string, lang: string) => Promise<void>;
+/**
+ * Cancel only the scheduled (future-dated) versions for a language, leaving the
+ * currently-live published version (publishedAt <= now) untouched.
+ */
+export declare const cancelScheduledEntryLang: (entryId: string, lang: string) => Promise<void>;

package/dist/core/server/entries/operations/update.js

@@ -80,7 +80,8 @@ export const updateEntryVersionCommandTypes = [
     'draft',
     'published-now',
     'published-scheduled',
-    'cancel-published'
+    'cancel-published',
+    'cancel-scheduled'
 ];
 const MAX_DRAFT_VERSIONS = 10;
 /** Prune old draft versions scoped to (entryId, lang) */
@@ -142,3 +143,25 @@ export const unpublishEntryLang = async (entryId, lang) => {
         });
     }));
 };
+/**
+ * Cancel only the scheduled (future-dated) versions for a language, leaving the
+ * currently-live published version (publishedAt <= now) untouched.
+ */
+export const cancelScheduledEntryLang = async (entryId, lang) => {
+    const now = new Date();
+    const versions = await getCMS().databaseAdapter.getEntryVersions({
+        entryIds: [entryId],
+        lang
+    });
+    await Promise.all(versions
+        .filter((v) => v.publishedAt !== null && new Date(v.publishedAt) > now)
+        .map((version) => {
+        return getCMS().databaseAdapter.updateEntryVersion({
+            id: version.id,
+            data: {
+                publishedAt: null,
+                publishedBy: null
+            }
+        });
+    }));
+};

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

@@ -1,15 +1,5 @@
-/**
- * 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 { 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;
-/**
- * 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;
-/**
- * Build full entry path using collection's pathTemplate.
- * If no template configured, returns the raw slug.
- */
+/** Build full entry path using collection's pathTemplate. */
 export declare function getEntryPath(configSlug: string, slug: string): string;