@xleddyl/nuxt-cms 0.9.4 → 0.10.0

package/dist/runtime/server/utils/media-references.d.ts

@@ -1,5 +1,5 @@
 import type { BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
-import type { CmsEntry, FieldConfig, MediaUsage } from '../../shared/index.js';
+import type { CmsEntry, CmsSiteSettings, FieldConfig, MediaUsage, MediaUsageReport } from '../../shared/index.js';
 export interface MediaReference {
     field: string;
     key: string;
@@ -11,6 +11,11 @@ export interface MediaUsageSource {
     entry: CmsEntry;
     rows: Record<string, unknown>[];
 }
+export declare function usageTitle(entry: CmsEntry, row: Record<string, unknown>): string | null;
+export declare function usageFields(entry: CmsEntry, row: Record<string, unknown>): Record<string, FieldConfig>;
 export declare function collectMediaUsage(sources: MediaUsageSource[], keys: string[]): Record<string, MediaUsage[]>;
+export declare const SITE_MEDIA_USAGE: Omit<MediaUsage, 'field'>;
+export declare function addSiteMediaUsage(usage: Record<string, MediaUsage[]>, settings: Pick<CmsSiteSettings, 'image'>): Record<string, MediaUsage[]>;
+export declare function redactMediaUsage(usage: Record<string, MediaUsage[]>, visible: (usage: MediaUsage) => boolean): MediaUsageReport;
 export declare function assertKnownMedia(references: MediaReference[], lookup: MediaLookup): Promise<void>;
 export declare function mediaKeysInTable(db: Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'select'>, table: SQLiteTable, keys: string[]): Promise<Set<string>>;

package/dist/runtime/server/utils/media-references.js

@@ -1,6 +1,14 @@
 import { inArray } from "drizzle-orm";
 import { createError } from "h3";
-import { PAGE_PATH_FIELD, pageFields, pageRouteOf, selectOptionLabel } from "../../shared/index.js";
+import {
+  CMS_SITE_SETTINGS_KEY,
+  PAGE_PATH_FIELD,
+  blockReferenceLabel,
+  pageFields,
+  pageRouteOf,
+  selectOptionLabel,
+  walkBlocks
+} from "../../shared/index.js";
 const LOOKUP_CHUNK = 90;
 function mediaKeysOf(value) {
   if (typeof value === "string") return value ? [value] : [];
@@ -12,25 +20,21 @@ function mediaKeysOf(value) {
 export function mediaReferences(fields, values) {
   const references = [];
   for (const [key, field] of Object.entries(fields)) {
-    const value = values[key];
-    if (field.type === "media") {
-      for (const mediaKey of mediaKeysOf(value)) references.push({ field: key, key: mediaKey });
-      continue;
-    }
-    if (field.type !== "blocks" || !Array.isArray(value)) continue;
-    value.forEach((item, index) => {
-      const block = item ? field.blocks?.[String(item.type)] : void 0;
-      for (const [blockFieldKey, blockField] of Object.entries(block?.fields ?? {})) {
-        if (blockField.type !== "media") continue;
-        for (const mediaKey of mediaKeysOf(item?.[blockFieldKey])) {
-          references.push({ field: `${key}[${index}].${blockFieldKey}`, key: mediaKey });
-        }
-      }
-    });
+    if (field.type !== "media") continue;
+    for (const mediaKey of mediaKeysOf(values[key]))
+      references.push({ field: key, key: mediaKey });
   }
+  walkBlocks(fields, values, ({ item, block, path }) => {
+    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
+      if (blockField.type !== "media") continue;
+      for (const mediaKey of mediaKeysOf(item[blockFieldKey])) {
+        references.push({ field: blockReferenceLabel(path, blockFieldKey), key: mediaKey });
+      }
+    }
+  });
   return references;
 }
-function titleOf(entry, row) {
+export function usageTitle(entry, row) {
   if (entry.kind === "page") {
     const path = row[PAGE_PATH_FIELD];
     return pageRouteOf(entry, String(row.id))?.label ?? (typeof path === "string" ? path : null);
@@ -48,7 +52,7 @@ function titleOf(entry, row) {
   }
   return null;
 }
-function fieldsOf(entry, row) {
+export function usageFields(entry, row) {
   const path = row[PAGE_PATH_FIELD];
   return entry.kind === "page" && typeof path === "string" ? pageFields(entry, path) : entry.fields;
 }
@@ -56,7 +60,7 @@ export function collectMediaUsage(sources, keys) {
   const usage = Object.fromEntries(keys.map((key) => [key, []]));
   for (const { name, entry, rows } of sources) {
     for (const row of rows) {
-      for (const reference of mediaReferences(fieldsOf(entry, row), row)) {
+      for (const reference of mediaReferences(usageFields(entry, row), row)) {
         const list = usage[reference.key];
         if (!list) continue;
         list.push({
@@ -64,7 +68,7 @@ export function collectMediaUsage(sources, keys) {
           label: entry.label,
           kind: entry.kind,
           id: entry.kind === "single" ? null : String(row.id),
-          title: titleOf(entry, row),
+          title: usageTitle(entry, row),
           field: reference.field
         });
       }
@@ -72,6 +76,31 @@ export function collectMediaUsage(sources, keys) {
   }
   return usage;
 }
+export const SITE_MEDIA_USAGE = {
+  collection: CMS_SITE_SETTINGS_KEY,
+  label: "Settings",
+  kind: "site",
+  id: null,
+  title: "Site settings"
+};
+export function addSiteMediaUsage(usage, settings) {
+  const list = settings.image ? usage[settings.image] : void 0;
+  if (list) list.push({ ...SITE_MEDIA_USAGE, field: "Share image" });
+  return usage;
+}
+export function redactMediaUsage(usage, visible) {
+  const report = { usage: {}, hidden: {} };
+  for (const [key, list] of Object.entries(usage)) {
+    const hidden = /* @__PURE__ */ new Set();
+    report.usage[key] = list.filter((item) => {
+      if (visible(item)) return true;
+      hidden.add(`${item.collection}\0${item.id ?? ""}`);
+      return false;
+    });
+    report.hidden[key] = hidden.size;
+  }
+  return report;
+}
 export async function assertKnownMedia(references, lookup) {
   if (!references.length) return;
   const known = await lookup([...new Set(references.map((reference) => reference.key))]);

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

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

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

@@ -1,11 +1,13 @@
 import cmsConfig from "#cms-config";
 import { useDb } from "#cms-db";
-import { collectMediaUsage } from "./media-references.js";
+import { addSiteMediaUsage, collectMediaUsage } from "./media-references.js";
 import { readPages } from "./page-storage.js";
 import { decodeRows, resolveTable } from "./registry.js";
-async function usageSources() {
+import { readSiteSettings } from "./site.js";
+export async function usageSources(include = () => true) {
   const sources = [];
   for (const [name, entry] of Object.entries(cmsConfig)) {
+    if (!include(name)) continue;
     const table = resolveTable(name);
     if (!table) continue;
     const rows = entry.kind === "page" ? await readPages(name, entry, table) : decodeRows(entry, await useDb().select().from(table));
@@ -14,5 +16,5 @@ async function usageSources() {
   return sources;
 }
 export async function loadMediaUsage(keys) {
-  return collectMediaUsage(await usageSources(), keys);
+  return addSiteMediaUsage(collectMediaUsage(await usageSources(), keys), await readSiteSettings());
 }

package/dist/runtime/server/utils/page-rows.d.ts

@@ -26,10 +26,12 @@ export interface EncodedPage {
     media: PageMediaRow[];
     fieldKeys: string[];
     mediaKeys: string[];
+    blockPrefixes: string[];
 }
 type Row = Record<string, unknown>;
 export declare const PAGE_BLOCK_TYPE_KEY = "_type";
 export declare function pageBlockKey(fieldKey: string, blockFieldKey: string): string;
+export declare function pageBlockPrefix(fieldKey: string): string;
 export declare function encodePageRows(entry: CmsEntry, pageId: string, values: Row): EncodedPage;
 export declare function decodePageRow(entry: CmsEntry, row: Row): Row;
 export declare function decodePageRows(entry: CmsEntry, rows: Row[]): Row[];

package/dist/runtime/server/utils/page-rows.js

@@ -1,6 +1,8 @@
-import { and, eq, getTableColumns, getTableName, inArray, sql } from "drizzle-orm";
+import { and, eq, getTableColumns, getTableName, inArray, or, sql } from "drizzle-orm";
 import {
+  BLOCK_HIDDEN_KEY,
   PAGE_PATH_FIELD,
+  declaresHiddenField,
   isMultiSelect,
   isTranslatableField,
   isTranslatableMediaField,
@@ -49,21 +51,19 @@ function decodeBlockMedia(field, raw) {
 export function pageBlockKey(fieldKey, blockFieldKey) {
   return `${fieldKey}.${blockFieldKey}`;
 }
-function blockOwnedKeys(key, field) {
-  const fields = /* @__PURE__ */ new Set([pageBlockKey(key, PAGE_BLOCK_TYPE_KEY)]);
-  const media = /* @__PURE__ */ new Set();
-  for (const block of Object.values(field.blocks ?? {})) {
-    for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
-      const blockKey = pageBlockKey(key, blockFieldKey);
-      if (blockField.type === "media") media.add(blockKey);
-      else fields.add(blockKey);
-    }
-  }
-  return { fields: [...fields], media: [...media] };
+export function pageBlockPrefix(fieldKey) {
+  return pageBlockKey(fieldKey, "");
 }
 export function encodePageRows(entry, pageId, values) {
   const rowFields = pageRowFields(entry);
-  const encoded = { columns: {}, fields: [], media: [], fieldKeys: [], mediaKeys: [] };
+  const encoded = {
+    columns: {},
+    fields: [],
+    media: [],
+    fieldKeys: [],
+    mediaKeys: [],
+    blockPrefixes: []
+  };
   const pushField = (key, position, value) => encoded.fields.push({ pageId, key, position, value });
   const pushMedia = (key, position, value) => encoded.media.push({ pageId, key, position, mediaKey: encodeMedia(value) });
   for (const [key, value] of Object.entries(values)) {
@@ -73,21 +73,22 @@ export function encodePageRows(entry, pageId, values) {
       continue;
     }
     if (field.type === "blocks") {
-      const owned = blockOwnedKeys(key, field);
-      encoded.fieldKeys.push(...owned.fields);
-      encoded.mediaKeys.push(...owned.media);
+      encoded.blockPrefixes.push(pageBlockPrefix(key));
       if (!Array.isArray(value)) continue;
       value.forEach((item, position) => {
         const type = String(item.type);
         const block = field.blocks?.[type];
         pushField(pageBlockKey(key, PAGE_BLOCK_TYPE_KEY), position, type);
-        for (const [blockFieldKey, blockValue] of Object.entries(item)) {
-          if (blockFieldKey === "type" || blockValue == null) continue;
-          const blockField = block?.fields[blockFieldKey];
+        for (const [blockFieldKey, blockField] of Object.entries(block?.fields ?? {})) {
+          const blockValue = item[blockFieldKey];
+          if (blockValue == null) continue;
           const blockKey = pageBlockKey(key, blockFieldKey);
-          if (blockField?.type === "media") pushMedia(blockKey, position, blockValue);
+          if (blockField.type === "media") pushMedia(blockKey, position, blockValue);
           else pushField(blockKey, position, encodeValue(blockField, blockValue));
         }
+        const hidden = item[BLOCK_HIDDEN_KEY];
+        if (!declaresHiddenField(block) && typeof hidden === "boolean")
+          pushField(pageBlockKey(key, BLOCK_HIDDEN_KEY), position, JSON.stringify(hidden));
       });
       continue;
     }
@@ -136,6 +137,10 @@ function decodeBlocks(key, field, fields, media) {
       const raw = fields.get(blockKey)?.get(position);
       item[blockFieldKey] = raw == null ? null : decodeValue(blockField, raw);
     }
+    if (!declaresHiddenField(field.blocks?.[type])) {
+      const hidden = fields.get(pageBlockKey(key, BLOCK_HIDDEN_KEY))?.get(position);
+      if (hidden === "true" || hidden === "false") item[BLOCK_HIDDEN_KEY] = hidden === "true";
+    }
     return item;
   });
 }
@@ -193,6 +198,16 @@ function chunks(items, size) {
   }
   return out;
 }
+function ownedRowConditions(key, keys, prefixes) {
+  const prefixed = prefixes.map(
+    (prefix) => sql`substr(${key}, 1, ${sql.raw(String(prefix.length))}) = ${prefix}`
+  );
+  const groups = chunks(keys, KEY_CHUNK);
+  if (!groups.length) return prefixed.length ? [or(...prefixed)] : [];
+  return groups.map(
+    (group, index) => index === 0 && prefixed.length ? or(inArray(key, group), ...prefixed) : inArray(key, group)
+  );
+}
 export function pageWriteStatements(db, dialect, tables, entry, route, values) {
   const encoded = encodePageRows(entry, route.key, values);
   const pageId = columnsOf(tables.page).id;
@@ -202,15 +217,13 @@ export function pageWriteStatements(db, dialect, tables, entry, route, values) {
   const statements = [
     db.insert(tables.page).values({ ...set, id: route.key, [PAGE_PATH_FIELD]: route.path }).onConflictDoUpdate({ target: pageId, set })
   ];
-  for (const keys of chunks(encoded.fieldKeys, KEY_CHUNK)) {
-    statements.push(
-      db.delete(tables.fields).where(and(eq(fieldColumns.pageId, route.key), inArray(fieldColumns.key, keys)))
-    );
-  }
-  for (const keys of chunks(encoded.mediaKeys, KEY_CHUNK)) {
-    statements.push(
-      db.delete(tables.media).where(and(eq(mediaColumns.pageId, route.key), inArray(mediaColumns.key, keys)))
-    );
+  for (const [table, columns, keys] of [
+    [tables.fields, fieldColumns, encoded.fieldKeys],
+    [tables.media, mediaColumns, encoded.mediaKeys]
+  ]) {
+    for (const condition of ownedRowConditions(columns.key, keys, encoded.blockPrefixes)) {
+      statements.push(db.delete(table).where(and(eq(columns.pageId, route.key), condition)));
+    }
   }
   for (const rows of chunks(encoded.fields, INSERT_CHUNK)) {
     statements.push(db.insert(tables.fields).values(rows));

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

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+import type { CmsEntry, CmsSessionUser } from '../../shared/index.js';
+import type { CmsAccess } from '../../shared/roles.js';
+export interface CmsAuthorized {
+    user: CmsSessionUser;
+    access: CmsAccess;
+}
+export declare function cmsAccessFor(role: string | null | undefined): CmsAccess;
+export declare function forbidden(message: string): never;
+export declare function assertCmsPermission(access: CmsAccess, permission: string): void;
+export declare function requireCmsAccess(event: H3Event): Promise<CmsAuthorized>;
+export declare function requireCmsPermission(event: H3Event, permission: string): Promise<CmsAuthorized>;
+export declare function assertDeleteAllowed(access: CmsAccess, name: string, entry: Pick<CmsEntry, 'drafts'>, status: unknown): void;
+export declare function assertPublishAllowed(access: CmsAccess, name: string, entry: Pick<CmsEntry, 'drafts'>, previous: unknown, next: unknown): void;

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

@@ -0,0 +1,43 @@
+import { createError } from "h3";
+import cmsConfig from "#cms-config";
+import cmsRoles from "#cms-roles";
+import {
+  can,
+  deletePermissionError,
+  publishPermissionError,
+  resolveCmsAccess
+} from "../../shared/roles.js";
+import { requireAdmin } from "./require-admin.js";
+export function cmsAccessFor(role) {
+  return resolveCmsAccess(role, cmsRoles, cmsConfig);
+}
+export function forbidden(message) {
+  throw createError({ statusCode: 403, statusMessage: message });
+}
+export function assertCmsPermission(access, permission) {
+  if (can(access, permission)) return;
+  if (!access.known) forbidden(`Your role '${access.role}' no longer exists`);
+  forbidden(`Missing permission: ${permission}`);
+}
+export async function requireCmsAccess(event) {
+  const cached = event.context.cmsAuthorized;
+  if (cached) return cached;
+  const user = await requireAdmin(event);
+  const authorized = { user, access: cmsAccessFor(user.role) };
+  event.context.cmsAuthorized = authorized;
+  return authorized;
+}
+export async function requireCmsPermission(event, permission) {
+  const authorized = await requireCmsAccess(event);
+  assertCmsPermission(authorized.access, permission);
+  return authorized;
+}
+export function assertDeleteAllowed(access, name, entry, status) {
+  assertCmsPermission(access, `${name}.delete`);
+  const message = deletePermissionError(access, name, entry, status);
+  if (message) forbidden(message);
+}
+export function assertPublishAllowed(access, name, entry, previous, next) {
+  const message = publishPermissionError(access, name, entry, previous, next);
+  if (message) forbidden(message);
+}

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

@@ -0,0 +1,18 @@
+import type { H3Event } from 'h3';
+import type { CmsSessionUser, FieldConfig } from '../../shared/index.js';
+import type { CmsBlockPreset, CmsPresetAction } from '../../shared/presets.js';
+import type { CmsAccess } from '../../shared/roles.js';
+export declare function requirePresetAccess(event: H3Event, action: CmsPresetAction): Promise<{
+    user: CmsSessionUser;
+    access: CmsAccess;
+}>;
+export declare function presetBlocksField(event: H3Event): {
+    source: string;
+    field: FieldConfig;
+};
+export declare function presetIdParam(event: H3Event): string;
+export declare function readPresetBody(event: H3Event): Promise<unknown>;
+export declare function readPresets(): Promise<CmsBlockPreset[]>;
+export declare function readPreset(id: string): Promise<CmsBlockPreset>;
+export declare function writePreset(preset: CmsBlockPreset): Promise<void>;
+export declare function deletePreset(id: string): Promise<void>;

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

@@ -0,0 +1,68 @@
+import { createError, getRequestHeader, getRouterParam, readRawBody } from "h3";
+import { eq, like } from "drizzle-orm";
+import { useDb } from "#cms-db";
+import { cms_settings } from "#cms-tables";
+import { blocksFieldAtSchemaPath, entryFieldsFor } from "../../shared/index.js";
+import {
+  CMS_PRESET_KEY_PREFIX,
+  CMS_PRESET_MAX_BYTES,
+  parseStoredPreset,
+  presetKey,
+  presetPermission
+} from "../../shared/presets.js";
+import { getRegistryEntry } from "./registry.js";
+import { assertCmsPermission, requireCmsAccess } from "./permissions.js";
+const PRESET_ID = /^preset_[A-Za-z0-9]{1,64}$/;
+export async function requirePresetAccess(event, action) {
+  const { user, access } = await requireCmsAccess(event);
+  assertCmsPermission(access, presetPermission(action, getRouterParam(event, "collection") ?? ""));
+  return { user, access };
+}
+export function presetBlocksField(event) {
+  const { name, entry } = getRegistryEntry(event);
+  const key = getRouterParam(event, "field") ?? "";
+  const field = blocksFieldAtSchemaPath(entryFieldsFor(entry), key);
+  if (!field) {
+    throw createError({ statusCode: 404, statusMessage: `Unknown blocks field: ${key}` });
+  }
+  return { source: `${name}.${key}`, field };
+}
+export function presetIdParam(event) {
+  const id = getRouterParam(event, "id") ?? "";
+  if (!PRESET_ID.test(id)) throw createError({ statusCode: 404, statusMessage: "Unknown preset" });
+  return id;
+}
+export async function readPresetBody(event) {
+  const tooLarge = () => createError({ statusCode: 413, statusMessage: "The preset is too large" });
+  if (Number(getRequestHeader(event, "content-length") ?? 0) > CMS_PRESET_MAX_BYTES)
+    throw tooLarge();
+  const text = await readRawBody(event, "utf8") ?? "";
+  if (new TextEncoder().encode(text).length > CMS_PRESET_MAX_BYTES) throw tooLarge();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw createError({ statusCode: 400, statusMessage: "Invalid JSON body" });
+  }
+}
+export async function readPresets() {
+  const rows = await useDb().select().from(cms_settings).where(like(cms_settings.key, `${CMS_PRESET_KEY_PREFIX}%`));
+  return rows.flatMap((row) => {
+    const preset = parseStoredPreset(row.value);
+    return preset && presetKey(preset.id) === row.key ? [preset] : [];
+  });
+}
+export async function readPreset(id) {
+  const [row] = await useDb().select().from(cms_settings).where(eq(cms_settings.key, presetKey(id)));
+  const preset = row ? parseStoredPreset(row.value) : null;
+  if (!preset) throw createError({ statusCode: 404, statusMessage: "Unknown preset" });
+  return preset;
+}
+export async function writePreset(preset) {
+  const key = presetKey(preset.id);
+  const value = JSON.stringify(preset);
+  const updatedAt = preset.updatedAt;
+  await useDb().insert(cms_settings).values({ key, value, updatedAt }).onConflictDoUpdate({ target: cms_settings.key, set: { value, updatedAt } });
+}
+export async function deletePreset(id) {
+  await useDb().delete(cms_settings).where(eq(cms_settings.key, presetKey(id)));
+}

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>;