@xleddyl/nuxt-cms 0.9.3 → 0.10.0

package/dist/runtime/server/utils/preview-links.d.ts

@@ -0,0 +1,207 @@
+import type { H3Event } from 'h3';
+import { z } from 'zod';
+import type { CmsCreatedPreviewLink, CmsEntry, CmsPreviewGrant, CmsPreviewLink, CmsSessionUser } from '../../shared/index.js';
+import type { WriteDb } from './write-statements.js';
+export declare const previewLinkInputSchema: z.ZodObject<{
+    duration: z.ZodEnum<{
+        "1h": "1h";
+        "1d": "1d";
+        "7d": "7d";
+        "30d": "30d";
+    }>;
+    locale: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export interface PreviewLinkAccess {
+    user: CmsSessionUser;
+    name: string;
+    entry: CmsEntry;
+}
+export declare function requirePreviewLinkAccess(event: H3Event, name: string, action: 'read' | 'update'): Promise<PreviewLinkAccess>;
+export declare function createPreviewToken(): string;
+export declare function hashPreviewToken(token: string): string;
+export declare function listPreviewLinks({ name, entry }: PreviewLinkAccess, itemId: string): Promise<CmsPreviewLink[]>;
+export declare function createPreviewLink({ name, entry, user }: PreviewLinkAccess, itemId: string, input: z.infer<typeof previewLinkInputSchema>): Promise<CmsCreatedPreviewLink>;
+export declare function revokePreviewLink({ name }: PreviewLinkAccess, itemId: string, linkId: string): Promise<void>;
+export declare function deleteItemPreviewLinksStatement(db: WriteDb, name: string, itemId: string): Omit<import("drizzle-orm/sqlite-core").SQLiteDeleteBase<import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "cms_preview_links";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tokenHash: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "token_hash";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        entry: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "entry";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        itemId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "item_id";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        locale: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "locale";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_by";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        revokedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "revoked_at";
+            tableName: "cms_preview_links";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>, "async" | "sync", unknown, undefined, false, "where">, "where">;
+export declare function findPreviewGrant(token: string | null): Promise<CmsPreviewGrant | null>;
+export declare function previewTokenOf(event: H3Event): string | null;
+export declare function hasPreviewHeader(event: H3Event): boolean;
+export declare function markPreviewResponse(event: H3Event): void;
+export declare function readPreviewGrant(event: H3Event): Promise<CmsPreviewGrant | null>;

package/dist/runtime/server/utils/preview-links.js

@@ -0,0 +1,161 @@
+import { createHash, randomBytes } from "node:crypto";
+import { and, asc, eq, gt, isNull, lte } from "drizzle-orm";
+import { createError, getHeader, setResponseHeaders } from "h3";
+import { z } from "zod";
+import cmsConfig from "#cms-config";
+import { useDb } from "#cms-db";
+import { cms_preview_links } from "#cms-tables";
+import {
+  PREVIEW_HEADER,
+  PREVIEW_LINK_DURATIONS,
+  PREVIEW_RESPONSE_HEADERS,
+  PREVIEW_TOKEN_BYTES,
+  contentItemPath,
+  isRoutedContent,
+  previewLinkExpiry,
+  previewLinkUrl,
+  previewTokenFrom
+} from "../../shared/index.js";
+import { normalizeTimestamp, nowTimestamp } from "../../shared/timestamps.js";
+import { customId } from "./custom-id.js";
+import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
+import { assertCmsPermission, requireCmsAccess } from "./permissions.js";
+export const previewLinkInputSchema = z.object({
+  duration: z.enum(
+    PREVIEW_LINK_DURATIONS.map((option) => option.value)
+  ),
+  locale: z.string().max(32).nullish()
+}).strict();
+export async function requirePreviewLinkAccess(event, name, action) {
+  const { user, access } = await requireCmsAccess(event);
+  const entry = routedEntry(name);
+  assertCmsPermission(access, `${name}.${action}`);
+  return { user, name, entry };
+}
+export function createPreviewToken() {
+  return randomBytes(PREVIEW_TOKEN_BYTES).toString("base64url");
+}
+export function hashPreviewToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+function routedEntry(name) {
+  const entry = cmsConfig[name];
+  if (!entry || !isRoutedContent(entry))
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Preview links need a content entry with a route"
+    });
+  return entry;
+}
+function previewLocale(locale) {
+  const { locales, defaultLocale } = getContentI18n();
+  if (!locale) return defaultLocale;
+  if (locales.length ? !locales.includes(locale) : locale !== defaultLocale)
+    throw createError({ statusCode: 400, statusMessage: `Unknown locale: ${locale}` });
+  return locale;
+}
+async function readItem(name, itemId) {
+  const table = resolveTable(name);
+  const id = table ? tableColumns(table).id : void 0;
+  const [row] = table && id ? await useDb().select().from(table).where(eq(id, itemId)).limit(1) : [];
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Item not found" });
+  return row;
+}
+function toPreviewLink(row, path) {
+  return {
+    id: row.id,
+    entry: row.entry,
+    itemId: row.itemId,
+    locale: row.locale ?? null,
+    path,
+    createdBy: row.createdBy ?? null,
+    createdAt: String(normalizeTimestamp(row.createdAt)),
+    expiresAt: row.expiresAt
+  };
+}
+function activeCondition(now) {
+  return and(isNull(cms_preview_links.revokedAt), gt(cms_preview_links.expiresAt, now));
+}
+async function pruneStaleLinks(now) {
+  await useDb().delete(cms_preview_links).where(lte(cms_preview_links.expiresAt, now));
+}
+export async function listPreviewLinks({ name, entry }, itemId) {
+  const item = await readItem(name, itemId);
+  const rows = await useDb().select().from(cms_preview_links).where(
+    and(
+      eq(cms_preview_links.entry, name),
+      eq(cms_preview_links.itemId, itemId),
+      activeCondition(nowTimestamp())
+    )
+  ).orderBy(asc(cms_preview_links.expiresAt));
+  const { defaultLocale } = getContentI18n();
+  return rows.map(
+    (row) => toPreviewLink(row, contentItemPath(entry, item, row.locale ?? defaultLocale) ?? "")
+  );
+}
+export async function createPreviewLink({ name, entry, user }, itemId, input) {
+  const locale = previewLocale(input.locale);
+  const item = await readItem(name, itemId);
+  const path = contentItemPath(entry, item, locale);
+  if (!path)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "The item has no address yet: give it a slug (and a publish date if the route uses one) and save"
+    });
+  const now = /* @__PURE__ */ new Date();
+  await pruneStaleLinks(now.toISOString());
+  const token = createPreviewToken();
+  const [row] = await useDb().insert(cms_preview_links).values({
+    id: customId("pvl"),
+    tokenHash: hashPreviewToken(token),
+    entry: name,
+    itemId,
+    locale,
+    createdBy: user.email,
+    createdAt: now.toISOString(),
+    expiresAt: previewLinkExpiry(input.duration, now)
+  }).returning();
+  return { link: toPreviewLink(row, path), url: previewLinkUrl(path, token) };
+}
+export async function revokePreviewLink({ name }, itemId, linkId) {
+  const [row] = await useDb().update(cms_preview_links).set({ revokedAt: nowTimestamp() }).where(
+    and(
+      eq(cms_preview_links.id, linkId),
+      eq(cms_preview_links.entry, name),
+      eq(cms_preview_links.itemId, itemId),
+      isNull(cms_preview_links.revokedAt)
+    )
+  ).returning({ id: cms_preview_links.id });
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Preview link not found" });
+}
+export function deleteItemPreviewLinksStatement(db, name, itemId) {
+  return db.delete(cms_preview_links).where(and(eq(cms_preview_links.entry, name), eq(cms_preview_links.itemId, itemId)));
+}
+export async function findPreviewGrant(token) {
+  if (!token) return null;
+  const [row] = await useDb().select({
+    entry: cms_preview_links.entry,
+    itemId: cms_preview_links.itemId,
+    expiresAt: cms_preview_links.expiresAt
+  }).from(cms_preview_links).where(
+    and(
+      eq(cms_preview_links.tokenHash, hashPreviewToken(token)),
+      activeCondition(nowTimestamp())
+    )
+  ).limit(1);
+  return row ?? null;
+}
+export function previewTokenOf(event) {
+  return previewTokenFrom(getHeader(event, PREVIEW_HEADER));
+}
+export function hasPreviewHeader(event) {
+  return getHeader(event, PREVIEW_HEADER) !== void 0;
+}
+export function markPreviewResponse(event) {
+  setResponseHeaders(event, PREVIEW_RESPONSE_HEADERS);
+}
+export async function readPreviewGrant(event) {
+  if (!hasPreviewHeader(event)) return null;
+  markPreviewResponse(event);
+  return findPreviewGrant(previewTokenOf(event)).catch(() => null);
+}

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { runBatch } from '#cms-db';
+import { cms_redirects } from '#cms-tables';
+import type { CmsContentMoves, CmsContentRouteItem, CmsEntry, CmsRedirect, CmsRedirectInput, CmsRedirectPlan, CmsRedirectTarget } from '../../shared/index.js';
+export declare const REDIRECTS_CACHE_TTL_MS = 30000;
+type RedirectRow = typeof cms_redirects.$inferSelect;
+type WriteDb = Parameters<Parameters<typeof runBatch>[0]>[0];
+export declare const redirectInputSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    status: z.ZodOptional<z.ZodLiteral<301 | 302 | 307 | 308>>;
+    keepQuery: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare function toRedirect(row: RedirectRow): CmsRedirect;
+export declare function listRedirects(): Promise<CmsRedirect[]>;
+export declare function readRedirectTable(): Promise<Map<string, CmsRedirectTarget>>;
+export declare function invalidateRedirects(): void;
+export declare function serializeRedirectWrite<T>(write: () => Promise<T>): Promise<T>;
+export declare function createRedirect(input: CmsRedirectInput): Promise<CmsRedirect>;
+export declare function updateRedirect(id: string, input: CmsRedirectInput): Promise<CmsRedirect>;
+export declare function deleteRedirects(ids: string[]): Promise<number>;
+export interface RedirectImportResult {
+    created: number;
+    updated: number;
+}
+export declare function importRedirects(inputs: CmsRedirectInput[]): Promise<RedirectImportResult>;
+export declare function isLivePath(path: string): Promise<boolean>;
+export declare function contentMovesOf(entry: CmsEntry, before: CmsContentRouteItem | undefined, after: CmsContentRouteItem): CmsContentMoves;
+export declare function planContentRedirects(moves: CmsContentMoves): Promise<CmsRedirectPlan | null>;
+export declare function redirectPlanStatements(db: WriteDb, plan: CmsRedirectPlan, now?: string): PromiseLike<unknown>[];
+export {};

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

@@ -0,0 +1,240 @@
+import { asc, eq, inArray } from "drizzle-orm";
+import { createError } from "h3";
+import { z } from "zod";
+import cmsConfig from "#cms-config";
+import { runBatch, useDb } from "#cms-db";
+import { cms_redirects } from "#cms-tables";
+import {
+  REDIRECT_FROM_MAX_LENGTH,
+  REDIRECT_STATUSES,
+  REDIRECT_TO_MAX_LENGTH,
+  contentItemMoves,
+  contentRouteLocales,
+  matchContentPath,
+  normalizeRedirectInput,
+  normalizeRedirectPath,
+  pageRoutes,
+  planRedirectMoves,
+  redirectErrors,
+  redirectFromErrors,
+  redirectTargetMap,
+  redirectToErrors
+} from "../../shared/index.js";
+import { normalizeTimestamp, nowTimestamp } from "../../shared/timestamps.js";
+import { cachedValue } from "./cached-value.js";
+import { findContentByPath } from "./content-routes.js";
+import { customId } from "./custom-id.js";
+import { mapConstraintErrors } from "./db-errors.js";
+import { getContentI18n } from "./registry.js";
+export const REDIRECTS_CACHE_TTL_MS = 3e4;
+export const redirectInputSchema = z.object({
+  from: z.string().max(REDIRECT_FROM_MAX_LENGTH),
+  to: z.string().max(REDIRECT_TO_MAX_LENGTH),
+  status: z.literal(REDIRECT_STATUSES).optional(),
+  keepQuery: z.boolean().optional()
+}).strict();
+export function toRedirect(row) {
+  return {
+    id: row.id,
+    from: row.from,
+    to: row.to,
+    status: row.status,
+    keepQuery: !!row.keepQuery,
+    source: row.source === "auto" ? "auto" : "manual",
+    createdAt: String(normalizeTimestamp(row.createdAt)),
+    updatedAt: String(normalizeTimestamp(row.updatedAt))
+  };
+}
+export async function listRedirects() {
+  const rows = await useDb().select().from(cms_redirects).orderBy(asc(cms_redirects.from));
+  return rows.map(toRedirect);
+}
+async function loadRedirectTable() {
+  const rows = await useDb().select({
+    from: cms_redirects.from,
+    to: cms_redirects.to,
+    status: cms_redirects.status,
+    keepQuery: cms_redirects.keepQuery
+  }).from(cms_redirects);
+  return new Map(
+    rows.map((row) => [
+      row.from,
+      { to: row.to, status: row.status, keepQuery: !!row.keepQuery }
+    ])
+  );
+}
+const redirectsCache = cachedValue(loadRedirectTable, REDIRECTS_CACHE_TTL_MS);
+export function readRedirectTable() {
+  return redirectsCache.get();
+}
+export function invalidateRedirects() {
+  redirectsCache.invalidate();
+}
+function invalid(errors) {
+  const duplicate = errors.some((error) => error.startsWith("A redirect from"));
+  return createError({
+    statusCode: duplicate ? 409 : 400,
+    statusMessage: duplicate ? "Duplicate redirect" : "Invalid redirect",
+    message: errors.join(". ")
+  });
+}
+function otherTargets(redirects, skipId) {
+  return redirectTargetMap(redirects.filter((redirect) => redirect.id !== skipId));
+}
+let pendingWrite = Promise.resolve();
+export function serializeRedirectWrite(write) {
+  const run = pendingWrite.then(write);
+  pendingWrite = run.catch(() => {
+  });
+  return run;
+}
+export function createRedirect(input) {
+  return serializeRedirectWrite(() => writeNewRedirect(input));
+}
+async function writeNewRedirect(input) {
+  const errors = redirectErrors(input, otherTargets(await listRedirects()));
+  if (errors.length) throw invalid(errors);
+  const draft = normalizeRedirectInput(input);
+  const now = nowTimestamp();
+  const [row] = await mapConstraintErrors(
+    () => useDb().insert(cms_redirects).values({
+      id: customId("rdr"),
+      ...draft,
+      source: "manual",
+      createdAt: now,
+      updatedAt: now
+    }).returning()
+  );
+  invalidateRedirects();
+  return toRedirect(row);
+}
+export function updateRedirect(id, input) {
+  return serializeRedirectWrite(() => writeRedirectUpdate(id, input));
+}
+async function writeRedirectUpdate(id, input) {
+  const redirects = await listRedirects();
+  if (!redirects.some((redirect) => redirect.id === id))
+    throw createError({ statusCode: 404, statusMessage: "Redirect not found" });
+  const errors = redirectErrors(input, otherTargets(redirects, id));
+  if (errors.length) throw invalid(errors);
+  const draft = normalizeRedirectInput(input);
+  const [row] = await mapConstraintErrors(
+    () => useDb().update(cms_redirects).set({ ...draft, source: "manual", updatedAt: nowTimestamp() }).where(eq(cms_redirects.id, id)).returning()
+  );
+  invalidateRedirects();
+  return toRedirect(row);
+}
+export async function deleteRedirects(ids) {
+  const rows = await useDb().delete(cms_redirects).where(inArray(cms_redirects.id, ids)).returning({ id: cms_redirects.id });
+  invalidateRedirects();
+  return rows.length;
+}
+function importError(errors) {
+  const shown = errors.slice(0, 10);
+  if (errors.length > shown.length) shown.push(`and ${errors.length - shown.length} more`);
+  return createError({
+    statusCode: 400,
+    statusMessage: "Invalid redirects",
+    message: shown.join(". ")
+  });
+}
+export function importRedirects(inputs) {
+  return serializeRedirectWrite(() => writeRedirectImport(inputs));
+}
+async function writeRedirectImport(inputs) {
+  const errors = [];
+  inputs.forEach((input, index) => {
+    for (const error of [...redirectFromErrors(input.from), ...redirectToErrors(input.to)])
+      errors.push(`Row ${index + 1}: ${error}`);
+  });
+  if (errors.length) throw importError(errors);
+  const drafts = inputs.map(normalizeRedirectInput);
+  const existing = await listRedirects();
+  const byFrom = new Map(existing.map((redirect) => [redirect.from, redirect]));
+  const final = new Map(
+    existing.map((redirect) => [redirect.from, redirect])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  drafts.forEach((draft, index) => {
+    if (seen.has(draft.from)) errors.push(`Row ${index + 1}: ${draft.from} is listed twice`);
+    seen.add(draft.from);
+    final.set(draft.from, draft);
+  });
+  const targets = redirectTargetMap([...final.values()]);
+  drafts.forEach((draft, index) => {
+    const others = new Map(targets);
+    others.delete(draft.from);
+    for (const error of redirectErrors(draft, others)) errors.push(`Row ${index + 1}: ${error}`);
+  });
+  if (errors.length) throw importError(errors);
+  const now = nowTimestamp();
+  let created = 0;
+  let updated = 0;
+  await mapConstraintErrors(
+    () => runBatch(
+      (db) => drafts.map((draft) => {
+        const current = byFrom.get(draft.from);
+        if (current) {
+          updated += 1;
+          return db.update(cms_redirects).set({ ...draft, source: "manual", updatedAt: now }).where(eq(cms_redirects.id, current.id));
+        }
+        created += 1;
+        return db.insert(cms_redirects).values({
+          id: customId("rdr"),
+          ...draft,
+          source: "manual",
+          createdAt: now,
+          updatedAt: now
+        });
+      })
+    )
+  );
+  invalidateRedirects();
+  return { created, updated };
+}
+function isStaticPath(path) {
+  return path.startsWith("/") && !/[[\]:*]/.test(path);
+}
+export async function isLivePath(path) {
+  const config = cmsConfig;
+  const normalized = normalizeRedirectPath(path);
+  for (const entry of Object.values(config)) {
+    if (entry.kind !== "page") continue;
+    if (pageRoutes(entry).some(
+      (route) => isStaticPath(route.path) && normalizeRedirectPath(route.path) === normalized
+    ))
+      return true;
+  }
+  for (const locale of contentRouteLocales(getContentI18n())) {
+    for (const match of matchContentPath(config, normalized, locale)) {
+      if (await findContentByPath(match.entry, normalized, locale)) return true;
+    }
+  }
+  return false;
+}
+export function contentMovesOf(entry, before, after) {
+  if (!before) return { moves: [], livePaths: [] };
+  return contentItemMoves(entry, before, after, contentRouteLocales(getContentI18n()));
+}
+export async function planContentRedirects(moves) {
+  if (!moves.moves.length) return null;
+  const existing = await useDb().select({ id: cms_redirects.id, from: cms_redirects.from, to: cms_redirects.to }).from(cms_redirects);
+  return planRedirectMoves(existing, moves.moves, moves.livePaths);
+}
+export function redirectPlanStatements(db, plan, now = nowTimestamp()) {
+  const statements = [];
+  if (plan.deletes.length)
+    statements.push(db.delete(cms_redirects).where(inArray(cms_redirects.id, plan.deletes)));
+  for (const { id, to } of plan.retargets) {
+    statements.push(
+      db.update(cms_redirects).set({ to, updatedAt: now }).where(eq(cms_redirects.id, id))
+    );
+  }
+  for (const { from, to } of plan.upserts) {
+    const values = { to, status: 301, keepQuery: true, source: "auto", updatedAt: now };
+    statements.push(
+      db.insert(cms_redirects).values({ id: customId("rdr"), from, createdAt: now, ...values }).onConflictDoUpdate({ target: cms_redirects.from, set: values })
+    );
+  }
+  return statements;
+}

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

@@ -56,7 +56,10 @@ export function getRegistryEntry(event) {
 }
 export function buildValidator(entry, path) {
   const fields = path ? pageFields(entry, path) : entry.fields;
-  return buildEntrySchema({ ...entry, fields, path }, getContentI18n());
+  return buildEntrySchema(
+    { ...entry, fields, path, config: cmsConfig },
+    getContentI18n()
+  );
 }
 export function requirePageRoute(entry, key) {
   const route = pageRouteOf(entry, key);

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

@@ -11,4 +11,12 @@ export declare function assertRelationTargets(entry: CmsEntry, lists: Record<str
 export declare function manyToManyStatements(db: CmsDb, name: string, sourceId: string, lists: Record<string, string[]>): PromiseLike<unknown>[];
 export declare function relationTitles(db: CmsDb, entry: CmsEntry, rows: Row[]): Promise<Record<string, Record<string, unknown>>>;
 export declare function attachManyToMany<T extends Row>(db: CmsDb, name: string, entry: CmsEntry, rows: T[]): Promise<T[]>;
+export interface SavedReadBack<T> {
+    row: T;
+    error: unknown;
+}
+export declare function readBackSaved<T extends Row>(name: string, entry: CmsEntry, row: T): Promise<SavedReadBack<T>>;
+export declare function savedReadBackError(error: unknown): import("h3").H3Error<{
+    saved: boolean;
+}>;
 export {};