@xleddyl/nuxt-cms 0.9.4 → 0.10.0

package/dist/runtime/server/utils/graphql.js

@@ -22,28 +22,46 @@ import { useRuntimeConfig } from "#imports";
 import {
   CONTENT_SLUG_FIELD,
   CONTENT_PUBLISHED_AT_FIELD,
+  contentItemPath,
+  contentItemPaths,
+  contentRouteLocales,
   decodeTranslatableMedia,
   entryFieldsFor,
+  blockFieldsDeep,
+  blocksFieldPaths,
   hasTranslatableBlockFields,
+  isExternalLinkUrl,
   isMultiValueField,
   isPrivateField,
+  isRoutedContent,
+  isStringListField,
   isTranslatableMediaField,
+  linkHref,
+  linkLabelText,
+  localeText,
   localizeBlocks,
+  mapBlocks,
   mediaPublicUrl,
   mediaTypeFor,
   pickTranslatedMedia,
+  previewGrantAllows,
   publicBlocks,
+  readLinkValue,
+  relationTarget,
   translatableFieldKeys
 } from "../../shared/index.js";
 import {
+  SITE_QUERY_FIELD,
   blockTypeName,
   blocksFieldTypeName,
   renderGraphqlSdl,
   typeName
 } from "../../shared/graphql-sdl.js";
 import { normalizeTimestampFields } from "../../shared/timestamps.js";
+import { findContentByPath } from "./content-routes.js";
 import { useMediaIndex } from "./media-index.js";
 import { readPages } from "./page-storage.js";
+import { readSiteSettings } from "./site.js";
 import {
   isListFilterOperator,
   joinListCondition,
@@ -52,7 +70,7 @@ import {
 } from "./list-filter.js";
 import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
 import { singleRowFirst } from "./single-row.js";
-import { visibilityConditions } from "./visibility.js";
+import { visibilityConditions, visibleOrPreviewConditions } from "./visibility.js";
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 50;
 const LOCALE = Symbol("locale");
@@ -99,6 +117,12 @@ function tableFor(name) {
 function publishedFilter(entry, table) {
   return visibilityConditions(entry, tableColumns(table));
 }
+function previewItemId(ctx, name) {
+  return previewGrantAllows(ctx.preview, name) ? ctx.preview.itemId : void 0;
+}
+function singleItemFilter(entry, table, ctx, name) {
+  return visibleOrPreviewConditions(entry, tableColumns(table), previewItemId(ctx, name));
+}
 function localeOf(parent) {
   return parent[LOCALE] ?? getContentI18n().defaultLocale;
 }
@@ -112,6 +136,23 @@ function resolveLocaleArg(locale) {
   }
   return String(locale);
 }
+function linkSource(value, locale) {
+  const link = readLinkValue(value);
+  if (!link || !link.url && !(link.entry && link.id)) return null;
+  return { link, locale };
+}
+function blockLinks(field, value, locale) {
+  return mapBlocks(field, value, (item, block) => {
+    const keys = Object.entries(block?.fields ?? {}).filter(([, blockField]) => blockField.type === "link").map(([key]) => key);
+    if (!keys.length) return item;
+    const resolved = { ...item };
+    for (const key of keys) resolved[key] = linkSource(resolved[key], locale);
+    return resolved;
+  });
+}
+function hasBlockLinks(field) {
+  return blockFieldsDeep(field).some((blockField) => blockField.type === "link");
+}
 function localizeRow(entry, row, locale) {
   const { defaultLocale } = getContentI18n();
   const result = normalizeTimestampFields({ ...row, [LOCALE]: locale });
@@ -126,9 +167,15 @@ function localizeRow(entry, row, locale) {
     result[key] = value?.[locale] ?? value?.[defaultLocale] ?? null;
   }
   for (const [key, field] of Object.entries(fields)) {
-    if (isPrivateField(field) || field.type !== "blocks") continue;
+    if (isPrivateField(field)) continue;
+    if (field.type === "link") {
+      result[key] = linkSource(result[key], locale);
+      continue;
+    }
+    if (field.type !== "blocks") continue;
     const visible = publicBlocks(field, result[key]);
-    result[key] = hasTranslatableBlockFields(field) ? localizeBlocks(field, visible, locale, defaultLocale) : visible;
+    const localized = hasTranslatableBlockFields(field) ? localizeBlocks(field, visible, locale, defaultLocale) : visible;
+    result[key] = hasBlockLinks(field) ? blockLinks(field, localized, locale) : localized;
   }
   return result;
 }
@@ -235,8 +282,8 @@ async function resolveMedia(ctx, key) {
   if (isLocalMedia()) {
     const file = (await useMediaIndex()).get(key);
     if (!file) return null;
-    const alt = await loadMediaAlt(ctx).load(key);
-    return mediaObject(key, { ...file, alt: alt ?? null });
+    const meta = await loadMediaMeta(ctx).load(key);
+    return mediaObject(key, { ...file, ...meta });
   }
   const row = await loadMedia(ctx).load(key);
   return row ? mediaObject(key, row) : null;
@@ -262,9 +309,9 @@ function loadManyToMany(ctx, name, key, field) {
     `m2m:${name}:${key}`,
     async (sourceIds) => {
       const config = cmsConfig;
-      const targetEntry = config[field.to];
+      const targetEntry = config[relationTarget(field)];
       const join = cmsTables[`${name}_${key}`];
-      const target = tableFor(field.to);
+      const target = tableFor(relationTarget(field));
       const joinCols = tableColumns(join);
       const rows = await useDb().select({ sourceId: joinCols.sourceId, target }).from(join).innerJoin(target, eq(joinCols.targetId, tableColumns(target).id)).where(
         and(inArray(joinCols.sourceId, sourceIds), ...publishedFilter(targetEntry, target))
@@ -294,14 +341,47 @@ function loadMedia(ctx) {
     );
   });
 }
-function loadMediaAlt(ctx) {
-  return getLoader(ctx, "mediaAlt", async (keys) => {
+function loadMediaMeta(ctx) {
+  return getLoader(ctx, "mediaMeta", async (keys) => {
     const media = cmsTables.cms_media;
     const columns = tableColumns(media);
-    const rows = await useDb().select({ key: columns.key, alt: columns.alt }).from(media).where(inArray(columns.key, keys));
-    return new Map(rows.map((row) => [row.key, row.alt ?? null]));
+    const rows = await useDb().select({
+      key: columns.key,
+      alt: columns.alt,
+      focalX: columns.focalX,
+      focalY: columns.focalY
+    }).from(media).where(inArray(columns.key, keys));
+    return new Map(
+      rows.map((row) => [
+        row.key,
+        {
+          alt: row.alt ?? null,
+          focalX: row.focalX ?? null,
+          focalY: row.focalY ?? null
+        }
+      ])
+    );
   });
 }
+async function resolveLinkHref(ctx, source) {
+  const config = cmsConfig;
+  const { link, locale } = source;
+  const entry = link.entry ? config[link.entry] : void 0;
+  if (link.url || !link.entry || !link.id || !isRoutedContent(entry))
+    return linkHref(config, link, locale);
+  const target = await loadById(ctx, link.entry).load(link.id);
+  return target ? linkHref(config, link, locale, target) : null;
+}
+function linkResolvers() {
+  return {
+    href: (source, _args, ctx) => resolveLinkHref(ctx, source),
+    label: (source) => linkLabelText(source.link.label, source.locale, getContentI18n().defaultLocale),
+    newTab: (source) => !!source.link.newTab,
+    external: (source) => isExternalLinkUrl(source.link.url),
+    entry: (source) => source.link.url ? null : source.link.entry ?? null,
+    id: (source) => source.link.url ? null : source.link.id ?? null
+  };
+}
 function mediaObject(key, row) {
   return {
     key,
@@ -312,6 +392,8 @@ function mediaObject(key, row) {
     size: row?.size ?? null,
     width: row?.width ?? null,
     height: row?.height ?? null,
+    focalX: row?.focalX ?? null,
+    focalY: row?.focalY ?? null,
     type: mediaTypeFor(row?.mime, key)
   };
 }
@@ -322,25 +404,33 @@ function entryResolvers(config, name, entry) {
     if (field.type === "relation" && field.cardinality === "many-to-many") {
       resolvers[key] = async (parent, _args, ctx) => {
         const rows = await loadManyToMany(ctx, name, key, field).load(parent.id);
-        return (rows ?? []).map((row) => localizeRow(config[field.to], row, localeOf(parent)));
+        return (rows ?? []).map(
+          (row) => localizeRow(config[relationTarget(field)], row, localeOf(parent))
+        );
       };
     } else if (field.type === "relation") {
       resolvers[key] = async (parent, _args, ctx) => {
         const id = parent[key];
         if (id == null) return null;
-        const row = await loadById(ctx, field.to).load(id);
-        return row ? localizeRow(config[field.to], row, localeOf(parent)) : null;
+        const row = await loadById(ctx, relationTarget(field)).load(id);
+        return row ? localizeRow(config[relationTarget(field)], row, localeOf(parent)) : null;
       };
     } else if (field.type === "media") {
       resolvers[key] = (parent, _args, ctx) => resolveMedia(ctx, parent[key]);
+    } else if (isStringListField(field)) {
+      resolvers[key] = (parent) => Array.isArray(parent[key]) ? parent[key] : [];
     }
   }
+  if (isRoutedContent(entry)) {
+    resolvers.path = (parent) => contentItemPath(entry, parent, localeOf(parent));
+    resolvers.paths = (parent) => contentItemPaths(entry, parent, contentRouteLocales(getContentI18n()));
+  }
   return resolvers;
 }
-function blockResolvers(name, key, field) {
+function blockResolvers(name, schemaPath, field) {
   const resolvers = {};
-  resolvers[blocksFieldTypeName(name, key)] = {
-    __resolveType: (value) => blockTypeName(name, key, String(value.type))
+  resolvers[blocksFieldTypeName(name, schemaPath)] = {
+    __resolveType: (value) => blockTypeName(name, schemaPath, String(value.type))
   };
   for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
     const mediaFields = Object.entries(block.fields).filter(([, f]) => f.type === "media");
@@ -349,7 +439,7 @@ function blockResolvers(name, key, field) {
     for (const [blockFieldKey] of mediaFields) {
       fieldLevel[blockFieldKey] = (parent, _args, ctx) => resolveMedia(ctx, parent[blockFieldKey]);
     }
-    resolvers[blockTypeName(name, key, blockName)] = fieldLevel;
+    resolvers[blockTypeName(name, schemaPath, blockName)] = fieldLevel;
   }
   return resolvers;
 }
@@ -358,14 +448,24 @@ export function buildCmsSchema() {
   const entries = Object.entries(config);
   const queryResolvers = {};
   const typeResolvers = {};
+  queryResolvers[SITE_QUERY_FIELD] = async (_, args, ctx) => {
+    const locale = resolveLocaleArg(args.locale);
+    const { defaultLocale } = getContentI18n();
+    const settings = await readSiteSettings();
+    return {
+      name: localeText(settings.name, locale, defaultLocale),
+      titleTemplate: settings.titleTemplate,
+      description: localeText(settings.description, locale, defaultLocale),
+      image: await resolveMedia(ctx, settings.image),
+      hidden: settings.hidden
+    };
+  };
   for (const [name, entry] of entries) {
     const gqlType = typeName(name);
     const fieldLevel = entryResolvers(config, name, entry);
     if (Object.keys(fieldLevel).length) typeResolvers[gqlType] = fieldLevel;
-    for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
-      if (field.type === "blocks" && !isPrivateField(field))
-        Object.assign(typeResolvers, blockResolvers(name, key, field));
-    }
+    for (const { field, schemaPath } of blocksFieldPaths(entryFieldsFor(entry)))
+      Object.assign(typeResolvers, blockResolvers(name, schemaPath, field));
     if (entry.kind === "page") {
       queryResolvers[name] = async (_, args) => {
         const locale = resolveLocaleArg(args.locale);
@@ -401,18 +501,32 @@ export function buildCmsSchema() {
       const rows = await useDb().select().from(table).where(where.length ? and(...where) : void 0).orderBy(...sortOrder(entry, table, args.sort)).limit(limit).offset(offset);
       return rows.map((row) => localizeRow(entry, row, locale));
     };
-    queryResolvers[`${name}ById`] = async (_, args) => {
+    queryResolvers[`${name}ById`] = async (_, args, ctx) => {
       const locale = resolveLocaleArg(args.locale);
       const table = tableFor(name);
-      const [row] = await useDb().select().from(table).where(and(eq(tableColumns(table).id, args.id), ...publishedFilter(entry, table))).limit(1);
+      const [row] = await useDb().select().from(table).where(
+        and(
+          eq(tableColumns(table).id, args.id),
+          ...singleItemFilter(entry, table, ctx, name)
+        )
+      ).limit(1);
       return row ? localizeRow(entry, row, locale) : null;
     };
     if (entry.kind === "content") {
-      queryResolvers[`${name}BySlug`] = async (_, args) => {
+      queryResolvers[`${name}BySlug`] = async (_, args, ctx) => {
         const locale = resolveLocaleArg(args.locale);
         const table = tableFor(name);
         const slug = tableColumns(table)[CONTENT_SLUG_FIELD];
-        const [row] = await useDb().select().from(table).where(and(eq(slug, args.slug), ...publishedFilter(entry, table))).limit(1);
+        const [row] = await useDb().select().from(table).where(and(eq(slug, args.slug), ...singleItemFilter(entry, table, ctx, name))).limit(1);
+        return row ? localizeRow(entry, row, locale) : null;
+      };
+    }
+    if (isRoutedContent(entry)) {
+      queryResolvers[`${name}ByPath`] = async (_, args, ctx) => {
+        const locale = resolveLocaleArg(args.locale);
+        const row = await findContentByPath(name, args.path, locale, {
+          previewId: previewItemId(ctx, name)
+        });
         return row ? localizeRow(entry, row, locale) : null;
       };
     }
@@ -436,11 +550,12 @@ export function buildCmsSchema() {
     typeDefs: renderGraphqlSdl(config),
     resolvers: {
       JSON: jsonScalar,
+      CmsLink: linkResolvers(),
       Query: queryResolvers,
       ...typeResolvers
     }
   });
 }
-export function createGraphqlContext() {
-  return { loaders: /* @__PURE__ */ new Map() };
+export function createGraphqlContext(preview = null) {
+  return { loaders: /* @__PURE__ */ new Map(), preview };
 }

package/dist/runtime/server/utils/hooks.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+import type { CmsEntryChange, CmsHookName, CmsHookUser, CmsMediaChange, CmsRuntimeHooks } from '../../shared/hooks.js';
+import type { CmsSessionUser } from '../../shared/users.js';
+type HookCallback = (...args: unknown[]) => unknown;
+export interface CmsHookHost {
+    callHookWith: (caller: (hooks: HookCallback[], args: unknown[]) => Promise<void>, name: string, ...args: unknown[]) => Promise<void>;
+}
+export type CmsHookLogger = (message: string, error: unknown) => void;
+export declare function hookUser(user: CmsSessionUser): CmsHookUser;
+export declare function runHooksIsolated(name: string, hooks: HookCallback[], args: unknown[], log?: CmsHookLogger): Promise<void>;
+export declare function dispatchCmsHook<Name extends CmsHookName>(host: () => CmsHookHost, event: H3Event, name: Name, payload: Parameters<CmsRuntimeHooks[Name]>[0], log?: CmsHookLogger): Promise<void>;
+export declare function emitEntryChange(event: H3Event, user: CmsSessionUser, change: Omit<CmsEntryChange, 'user' | 'at' | 'path' | 'status' | 'item'> & Partial<Pick<CmsEntryChange, 'path' | 'status' | 'item'>>): Promise<void>;
+export declare function emitMediaChange(event: H3Event, user: CmsSessionUser, change: Pick<CmsMediaChange, 'action' | 'keys'> & Partial<Pick<CmsMediaChange, 'folder' | 'from'>>): Promise<void>;
+export {};

package/dist/runtime/server/utils/hooks.js

@@ -0,0 +1,71 @@
+import { useNitroApp } from "nitropack/runtime";
+import { CMS_ENTRY_CHANGE_HOOK, CMS_MEDIA_CHANGE_HOOK } from "../../shared/hooks.js";
+const logHookError = (message, error) => console.error(message, error);
+export function hookUser(user) {
+  return {
+    id: user.id ?? null,
+    email: user.email,
+    name: user.name ?? null,
+    role: user.role ?? (user.id ? "admin" : "superadmin")
+  };
+}
+export function runHooksIsolated(name, hooks, args, log = logHookError) {
+  return Promise.all(
+    hooks.map(
+      (hook) => Promise.resolve().then(() => hook(...args)).catch((error) => {
+        log(`[nuxt-cms] a '${name}' hook failed:`, error);
+      })
+    )
+  ).then(() => void 0);
+}
+export function dispatchCmsHook(host, event, name, payload, log = logHookError) {
+  const context = { event };
+  const task = Promise.resolve().then(
+    () => host().callHookWith(
+      (hooks, args) => runHooksIsolated(name, hooks, args, log),
+      name,
+      payload,
+      context
+    )
+  ).catch((error) => {
+    log(`[nuxt-cms] the '${name}' hooks failed:`, error);
+  });
+  const waitUntil = event.waitUntil;
+  if (typeof waitUntil === "function") {
+    try {
+      waitUntil.call(event, task);
+    } catch (error) {
+      log(`[nuxt-cms] waitUntil failed for '${name}':`, error);
+    }
+  }
+  return task;
+}
+function cloneItem(item) {
+  try {
+    return structuredClone(item);
+  } catch {
+    return { ...item };
+  }
+}
+function hookHost() {
+  return useNitroApp().hooks;
+}
+export function emitEntryChange(event, user, change) {
+  return dispatchCmsHook(hookHost, event, CMS_ENTRY_CHANGE_HOOK, {
+    path: null,
+    status: null,
+    ...change,
+    item: change.item ? cloneItem(change.item) : null,
+    user: hookUser(user),
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+export function emitMediaChange(event, user, change) {
+  return dispatchCmsHook(hookHost, event, CMS_MEDIA_CHANGE_HOOK, {
+    folder: null,
+    from: null,
+    ...change,
+    user: hookUser(user),
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}

package/dist/runtime/server/utils/import.d.ts

@@ -1,8 +1,9 @@
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { CmsDb } from '#cms-db';
-import type { CmsEntry, CmsI18n } from '../../shared/index.js';
+import type { CmsConfig, CmsEntry, CmsI18n } from '../../shared/index.js';
 import type { CmsImportAction, CmsImportIssue, CmsImportMode, CmsImportPreview, CmsImportSourceRow, CmsTransferFormat } from '../../shared/transfer.js';
 import type { MediaLookup } from './media-references.js';
+import type { CmsRedirectPlan } from '../../shared/index.js';
 type Row = Record<string, unknown>;
 export interface PreparedImportRow {
     index: number;
@@ -18,8 +19,10 @@ export interface ImportContext {
     table: SQLiteTable;
     mode: CmsImportMode;
     media: MediaLookup | null;
+    canPublish?: boolean;
 }
-export declare function validateImportRows(entry: CmsEntry, rows: CmsImportSourceRow[], i18n: CmsI18n): PreparedImportRow[];
+export declare function existingImportIds(db: CmsDb, table: SQLiteTable, rows: CmsImportSourceRow[]): Promise<Set<string>>;
+export declare function validateImportRows(entry: CmsEntry, rows: CmsImportSourceRow[], i18n: CmsI18n, isCreate?: (id: string | null) => boolean, config?: CmsConfig): PreparedImportRow[];
 export declare function checkImportRows(rows: PreparedImportRow[], context: ImportContext): Promise<PreparedImportRow[]>;
 export declare function importPreview(entry: CmsEntry, rows: PreparedImportRow[], options: {
     format: CmsTransferFormat;
@@ -27,5 +30,7 @@ export declare function importPreview(entry: CmsEntry, rows: PreparedImportRow[]
     defaultLocale: string;
     errors?: string[];
 }): CmsImportPreview;
+export declare function assignImportIds(entry: CmsEntry, rows: PreparedImportRow[]): PreparedImportRow[];
 export declare function importWriteStatements(db: CmsDb, name: string, entry: CmsEntry, table: SQLiteTable, rows: PreparedImportRow[]): PromiseLike<unknown>[];
+export declare function planImportRedirects(db: CmsDb, entry: CmsEntry, table: SQLiteTable, rows: PreparedImportRow[]): Promise<CmsRedirectPlan | null>;
 export {};

package/dist/runtime/server/utils/import.js

@@ -1,7 +1,20 @@
-import { eq, inArray } from "drizzle-orm";
+import { eq, inArray, sql } from "drizzle-orm";
+import {
+  isRoutedContent,
+  mergeContentMoves,
+  relationTarget,
+  rowAfterUpdate
+} from "../../shared/index.js";
 import { uniqueFieldKeys } from "../../shared/duplicate.js";
+import {
+  changedImmutableKeys,
+  immutableFieldKeys,
+  isCaseInsensitiveUnique,
+  uniqueCompareValue,
+  withEntryDefaults
+} from "../../shared/field-options.js";
 import { IMPORT_ID_PATTERN, importIssuePath, importRowTitle } from "../../shared/transfer.js";
-import { buildEntrySchema } from "../../shared/validation.js";
+import { buildEntrySchema, validationMessages } from "../../shared/validation.js";
 import { customId } from "./custom-id.js";
 import { mediaReferences } from "./media-references.js";
 import {
@@ -11,11 +24,18 @@ import {
   withTimestamps,
   withUpdatedAt
 } from "./registry.js";
+import { contentMovesOf, planContentRedirects } from "./redirects.js";
 import { manyToManyStatements, splitRelationValues } from "./relations.js";
 import { chunks, KEY_CHUNK } from "./write-statements.js";
 const META_KEYS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
-export function validateImportRows(entry, rows, i18n) {
-  const schema = buildEntrySchema(entry, i18n);
+export async function existingImportIds(db, table, rows) {
+  const ids = rows.flatMap(
+    (row) => typeof row.values.id === "string" && IMPORT_ID_PATTERN.test(row.values.id) ? [row.values.id] : []
+  );
+  return ids.length ? existingIds(db, table, ids) : /* @__PURE__ */ new Set();
+}
+export function validateImportRows(entry, rows, i18n, isCreate = () => true, config) {
+  const schema = buildEntrySchema({ ...entry, config }, i18n);
   return rows.map((row) => {
     const errors = [...row.errors];
     const rawId = row.values.id;
@@ -28,9 +48,10 @@ export function validateImportRows(entry, rows, i18n) {
           message: "Invalid id: use letters, numbers, _ and -, up to 128 characters"
         });
     }
-    const input = Object.fromEntries(
+    const given = Object.fromEntries(
       Object.entries(row.values).filter(([key]) => !META_KEYS.has(key))
     );
+    const input = isCreate(id) ? withEntryDefaults(entry.fields, given, i18n) : given;
     const result = schema.safeParse(input);
     if (!result.success) {
       const reported = new Set(errors.map((issue) => issue.path));
@@ -82,16 +103,17 @@ async function checkIds(rows, context) {
 async function checkRelations(rows, context) {
   const fileIds = new Set(rows.flatMap((row) => row.id ? [row.id] : []));
   for (const [key, field] of Object.entries(context.entry.fields)) {
-    if (field.type !== "relation" || !field.to) continue;
-    const target = resolveTable(field.to);
+    const to = relationTarget(field);
+    if (field.type !== "relation" || !to) continue;
+    const target = resolveTable(to);
     if (!target) continue;
     const wanted = rows.flatMap((row) => relationIds(row.values?.[key]));
     if (!wanted.length) continue;
     const found = await existingIds(context.db, target, wanted);
-    if (field.to === context.name) for (const id of fileIds) found.add(id);
+    if (to === context.name) for (const id of fileIds) found.add(id);
     for (const row of rows) {
       const missing = relationIds(row.values?.[key]).filter((id) => !found.has(id));
-      if (missing.length) addError(row, key, `Unknown ${field.to} id: ${missing.join(", ")}`);
+      if (missing.length) addError(row, key, `Unknown ${to} id: ${missing.join(", ")}`);
     }
   }
 }
@@ -99,25 +121,45 @@ async function checkUnique(rows, context) {
   const columns = context.table;
   for (const key of uniqueFieldKeys(context.entry)) {
     const column = columns[key];
+    const field = context.entry.fields[key];
     if (!column) continue;
     const owners = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const value = row.values?.[key];
-      if (typeof value !== "string" || !value) continue;
-      const owner = owners.get(value);
+      if (!(typeof value === "string" && value || typeof value === "number")) continue;
+      const compared = uniqueCompareValue(field, value);
+      const owner = owners.get(compared);
       if (owner) addError(row, key, `Same value as row ${owner.index}`);
-      else owners.set(value, row);
+      else owners.set(compared, row);
     }
+    const lower = isCaseInsensitiveUnique(field);
     for (const chunk of chunks([...owners.keys()], KEY_CHUNK)) {
-      const found = await context.db.select({ id: columns.id, value: column }).from(context.table).where(inArray(column, chunk));
+      const found = await context.db.select({ id: columns.id, value: column }).from(context.table).where(lower ? inArray(sql`lower(${column})`, chunk) : inArray(column, chunk));
       for (const match of found) {
-        const row = owners.get(String(match.value));
+        const row = owners.get(uniqueCompareValue(field, match.value));
         if (row && row.id !== String(match.id))
           addError(row, key, "This value is already used by another entry");
       }
     }
   }
 }
+async function checkImmutable(rows, context) {
+  const columns = context.table;
+  const keys = immutableFieldKeys(context.entry.fields).filter((key) => columns[key]);
+  const updated = rows.filter((row) => row.action === "update" && row.id && row.values);
+  if (!keys.length || !updated.length) return;
+  const saved = /* @__PURE__ */ new Map();
+  const selection = Object.fromEntries(keys.map((key) => [key, columns[key]]));
+  for (const chunk of chunks([...new Set(updated.map((row) => row.id))], KEY_CHUNK)) {
+    const found = await context.db.select({ ...selection, id: columns.id }).from(context.table).where(inArray(columns.id, chunk));
+    for (const match of found) saved.set(String(match.id), match);
+  }
+  const message = validationMessages().immutable;
+  for (const row of updated) {
+    for (const key of changedImmutableKeys(context.entry.fields, saved.get(row.id), row.values))
+      addError(row, key, message);
+  }
+}
 async function checkMedia(rows, context) {
   if (!context.media) return;
   const references = new Map(
@@ -133,11 +175,37 @@ async function checkMedia(rows, context) {
     }
   }
 }
+async function publishedIds(db, table, ids) {
+  const columns = table;
+  const found = /* @__PURE__ */ new Set();
+  for (const chunk of chunks([...new Set(ids)], KEY_CHUNK)) {
+    const rows = await db.select({ id: columns.id, status: columns.status }).from(table).where(inArray(columns.id, chunk));
+    for (const row of rows) if (row.status === "published") found.add(String(row.id));
+  }
+  return found;
+}
+async function checkPublish(rows, context) {
+  if (context.canPublish !== false || !context.entry.drafts) return;
+  const permission = `${context.name}.publish`;
+  for (const row of rows) {
+    if (row.values?.status === "published")
+      addError(row, "status", `Publishing needs the ${permission} permission`);
+  }
+  const updated = rows.flatMap((row) => row.action === "update" && row.id ? [row.id] : []);
+  if (!updated.length) return;
+  const published = await publishedIds(context.db, context.table, updated);
+  for (const row of rows) {
+    if (row.action === "update" && row.id && published.has(row.id))
+      addError(row, "id", `Editing a published item needs the ${permission} permission`);
+  }
+}
 export async function checkImportRows(rows, context) {
   await checkIds(rows, context);
   await checkRelations(rows, context);
   await checkUnique(rows, context);
+  await checkImmutable(rows, context);
   await checkMedia(rows, context);
+  await checkPublish(rows, context);
   return rows;
 }
 export function importPreview(entry, rows, options) {
@@ -165,6 +233,9 @@ function deferredSelfRelations(entry, name) {
     ([, field]) => field.type === "relation" && field.to === name && field.cardinality !== "many-to-many" && !field.required
   ).map(([key]) => key);
 }
+export function assignImportIds(entry, rows) {
+  return rows.map((row) => row.values && !row.id ? { ...row, id: customId(entry.id) } : row);
+}
 export function importWriteStatements(db, name, entry, table, rows) {
   const idCol = table.id;
   const created = new Set(
@@ -200,3 +271,26 @@ export function importWriteStatements(db, name, entry, table, rows) {
   }
   return [...main, ...later];
 }
+export async function planImportRedirects(db, entry, table, rows) {
+  if (!isRoutedContent(entry)) return null;
+  const updates = rows.filter((row) => row.action === "update" && row.values && row.id);
+  if (!updates.length) return null;
+  const idCol = table.id;
+  const before = /* @__PURE__ */ new Map();
+  for (const ids of chunks(
+    updates.map((row) => row.id),
+    KEY_CHUNK
+  )) {
+    const found = await db.select().from(table).where(inArray(idCol, ids));
+    for (const row of found) before.set(String(row.id), row);
+  }
+  const moves = [];
+  for (const row of updates) {
+    const existing = before.get(row.id);
+    if (!existing) continue;
+    const { values } = splitRelationValues(entry, encodeColumnValues(entry, row.values));
+    const after = rowAfterUpdate(existing, withContentDefaults(entry, values));
+    moves.push(contentMovesOf(entry, existing, after));
+  }
+  return planContentRedirects(mergeContentMoves(moves));
+}

package/dist/runtime/server/utils/link-usage.d.ts

@@ -0,0 +1,4 @@
+import type { MediaUsage } from '../../shared/index.js';
+import type { MediaUsageSource } from './media-references.js';
+export declare function collectLinkUsage(sources: MediaUsageSource[], keys: string[]): Record<string, MediaUsage[]>;
+export declare function loadLinkUsage(keys: string[], include?: (name: string) => boolean): Promise<Record<string, MediaUsage[]>>;

package/dist/runtime/server/utils/link-usage.js

@@ -0,0 +1,28 @@
+import { linkReferences, linkTargetKey } from "../../shared/index.js";
+import { usageFields, usageTitle } from "./media-references.js";
+import { usageSources } from "./media-usage.js";
+export function collectLinkUsage(sources, keys) {
+  const usage = Object.fromEntries(keys.map((key) => [key, []]));
+  for (const { name, entry, rows } of sources) {
+    for (const row of rows) {
+      const id = entry.kind === "single" ? null : String(row.id);
+      for (const reference of linkReferences(usageFields(entry, row), row)) {
+        if (reference.entry === name && reference.id === id) continue;
+        const list = usage[linkTargetKey(reference.entry, reference.id)];
+        if (!list) continue;
+        list.push({
+          collection: name,
+          label: entry.label,
+          kind: entry.kind,
+          id,
+          title: usageTitle(entry, row),
+          field: reference.field
+        });
+      }
+    }
+  }
+  return usage;
+}
+export async function loadLinkUsage(keys, include) {
+  return collectLinkUsage(await usageSources(include), keys);
+}