@xleddyl/nuxt-cms 0.2.3 → 0.3.0

package/dist/runtime/server/api/media-download.get.js

@@ -0,0 +1,90 @@
+import { createReadStream, existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { eq } from "drizzle-orm";
+import {
+  createError,
+  defineEventHandler,
+  getRequestURL,
+  getValidatedQuery,
+  sendRedirect,
+  sendStream,
+  setResponseHeaders
+} from "h3";
+import { z } from "zod";
+import { useDb } from "#cms-db";
+import { cms_media } from "#cms-tables";
+import { useRuntimeConfig } from "#imports";
+import { isMediaFolderMarker, mediaFilename, mediaPublicUrl } from "../../shared/index.js";
+import { objectKeySchema } from "../../shared/validation.js";
+import { encodeKey, presignedDownloadUrl, useMediaConfig } from "../utils/media.js";
+import { attachmentDisposition } from "../utils/media-download.js";
+import { mediaFilePath } from "../utils/media-fs.js";
+import { useMediaIndex } from "../utils/media-index.js";
+import { mediaMimeForKey } from "../utils/media-sync.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const querySchema = z.object({ key: objectKeySchema });
+function notFound() {
+  throw createError({ statusCode: 404, statusMessage: "Media not found" });
+}
+async function assertKnownRow(key) {
+  const [row] = await useDb().select({ mime: cms_media.mime }).from(cms_media).where(eq(cms_media.key, key)).limit(1);
+  if (!row) notFound();
+  return row.mime;
+}
+async function sendDiskFile(event, root, key, mime, disposition) {
+  const path = mediaFilePath(root, key);
+  if (!path) throw createError({ statusCode: 400, statusMessage: "Invalid object key" });
+  const info = await stat(path).catch(() => null);
+  if (!info?.isFile()) notFound();
+  setResponseHeaders(event, {
+    "content-type": mime ?? mediaMimeForKey(key) ?? "application/octet-stream",
+    "content-disposition": disposition,
+    "content-length": info.size,
+    "cache-control": "private, no-store",
+    "x-content-type-options": "nosniff"
+  });
+  return sendStream(event, createReadStream(path));
+}
+async function sendRemoteFile(event, baseUrl, key, disposition) {
+  const publicUrl = mediaPublicUrl(baseUrl, encodeKey(key));
+  if (!publicUrl) notFound();
+  const upstream = await fetch(new URL(publicUrl, getRequestURL(event).origin));
+  if (!upstream.ok || !upstream.body) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: `Media source answered ${upstream.status}`
+    });
+  }
+  const length = upstream.headers.get("content-length");
+  setResponseHeaders(event, {
+    "content-type": upstream.headers.get("content-type") ?? mediaMimeForKey(key) ?? "application/octet-stream",
+    "content-disposition": disposition,
+    ...length ? { "content-length": Number(length) } : {},
+    "cache-control": "private, no-store",
+    "x-content-type-options": "nosniff"
+  });
+  return sendStream(event, upstream.body);
+}
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { media } = useMediaConfig(event);
+  const { key } = await getValidatedQuery(event, querySchema.parse);
+  if (isMediaFolderMarker(key)) notFound();
+  const disposition = attachmentDisposition(mediaFilename(key));
+  if (media.storage === "s3") {
+    await assertKnownRow(key);
+    return sendRedirect(event, await presignedDownloadUrl(media, key, disposition), 302);
+  }
+  if (media.storage === "filesystem") {
+    const mime = await assertKnownRow(key);
+    return sendDiskFile(event, media.dir, key, mime, disposition);
+  }
+  const file = (await useMediaIndex()).get(key);
+  if (!file) notFound();
+  const { localRoot } = useRuntimeConfig(event).cms.media;
+  if (localRoot && existsSync(localRoot)) {
+    return sendDiskFile(event, localRoot, key, file.mime, disposition);
+  }
+  const { mediaBaseUrl } = useRuntimeConfig(event).public.cms;
+  return sendRemoteFile(event, mediaBaseUrl, key, disposition);
+});

package/dist/runtime/server/api/search.get.d.ts

@@ -0,0 +1,3 @@
+import type { CmsSearchResponse } from '../../shared/search.js';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<CmsSearchResponse>>;
+export default _default;

package/dist/runtime/server/api/search.get.js

@@ -0,0 +1,24 @@
+import { defineEventHandler, getValidatedQuery } from "h3";
+import { z } from "zod";
+import cmsConfig from "#cms-config";
+import { cmsDialect, useDb } from "#cms-db";
+import * as cmsTables from "#cms-tables";
+import { CMS_SEARCH_MAX_LENGTH } from "../../shared/search.js";
+import { getContentI18n } from "../utils/registry.js";
+import { requireAdmin } from "../utils/require-admin.js";
+import { searchCms } from "../utils/search.js";
+const querySchema = z.object({
+  q: z.string().max(CMS_SEARCH_MAX_LENGTH).default("")
+});
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { q } = await getValidatedQuery(event, querySchema.parse);
+  return searchCms({
+    db: useDb(),
+    dialect: cmsDialect,
+    config: cmsConfig,
+    tables: cmsTables,
+    i18n: getContentI18n(),
+    query: q
+  });
+});

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

@@ -0,0 +1 @@
+export declare function attachmentDisposition(filename: string): string;

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

@@ -0,0 +1,8 @@
+export function attachmentDisposition(filename) {
+  const fallback = filename.replace(/[^\x20-\x7e]|["\\%]/g, "_");
+  const encoded = encodeURIComponent(filename).replace(
+    /['()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+  return `attachment; filename="${fallback}"; filename*=UTF-8''${encoded}`;
+}

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

@@ -32,6 +32,7 @@ export declare function useMediaConfig(event: H3Event): {
     publicUrl: (key: string) => string | null;
 };
 export declare function mediaUploadPath(key: string): string;
+export declare function presignedDownloadUrl(media: MediaConfig, key: string, disposition: string): Promise<string>;
 export declare function useMediaStorage(event: H3Event): {
     media: MediaConfig;
     store: MediaStore;

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

@@ -94,14 +94,29 @@ function filesystemStore(dir) {
     remove: (key) => removeMediaFile(dir, key)
   };
 }
-function s3Store(media) {
-  const client = new AwsClient({
+function s3Client(media) {
+  return new AwsClient({
     accessKeyId: media.accessKeyId,
     secretAccessKey: media.secretAccessKey,
     region: media.region,
     service: "s3"
   });
-  const bucketUrl = `${media.endpoint.replace(/\/+$/, "")}/${media.bucket}`;
+}
+function s3BucketUrl(media) {
+  return `${media.endpoint.replace(/\/+$/, "")}/${media.bucket}`;
+}
+export async function presignedDownloadUrl(media, key, disposition) {
+  const url = new URL(`${s3BucketUrl(media)}/${encodeKey(key)}`);
+  url.searchParams.set("X-Amz-Expires", String(media.presignExpiry));
+  url.searchParams.set("response-content-disposition", disposition);
+  const signed = await s3Client(media).sign(new Request(url, { method: "GET" }), {
+    aws: { signQuery: true }
+  });
+  return signed.url;
+}
+function s3Store(media) {
+  const client = s3Client(media);
+  const bucketUrl = s3BucketUrl(media);
   return {
     async uploadTarget(key, contentType, size) {
       const url = new URL(`${bucketUrl}/${key}`);

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

@@ -0,0 +1,20 @@
+import type { SQL } from 'drizzle-orm';
+import type { AnySQLiteColumn, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import type { CmsConfig, CmsI18n } from '../../shared/index.js';
+import type { CmsSearchHit, CmsSearchResponse } from '../../shared/search.js';
+export type SearchDb = Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'select' | 'selectDistinct'>;
+export type SearchDialect = 'sqlite' | 'postgres';
+export interface CmsSearchOptions {
+    db: SearchDb;
+    dialect: SearchDialect;
+    config: CmsConfig;
+    tables: Record<string, unknown>;
+    i18n: CmsI18n;
+    query: string;
+}
+export declare function searchLikeCondition(dialect: SearchDialect, column: AnySQLiteColumn, pattern: string): SQL;
+export declare function searchCmsValues(options: CmsSearchOptions): Promise<{
+    hits: CmsSearchHit[];
+    truncated: boolean;
+}>;
+export declare function searchCms(options: CmsSearchOptions): Promise<CmsSearchResponse>;

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

@@ -0,0 +1,233 @@
+import { desc, inArray, or, sql } from "drizzle-orm";
+import {
+  decodeTranslatableValue,
+  isMultiSelect,
+  isTranslatableField,
+  mediaFilename,
+  pageColumnFields,
+  pageFields,
+  pageFieldsTableName,
+  pageMediaTableName,
+  pageRouteOf
+} from "../../shared/index.js";
+import {
+  CMS_SEARCH_HITS_PER_ROW,
+  CMS_SEARCH_MIN_LENGTH,
+  CMS_SEARCH_ROWS_PER_ENTRY,
+  CMS_SEARCH_VALUE_LIMIT,
+  cmsSearchLink,
+  normalizeSearchQuery,
+  searchCmsLabels,
+  searchFieldPath,
+  searchLikePattern,
+  searchSnippet,
+  stripMarkup
+} from "../../shared/search.js";
+import { decodePageRows, selectPages } from "./page-rows.js";
+const VALUE_TYPES = /* @__PURE__ */ new Set(["text", "richtext", "email", "slug", "select", "json", "blocks"]);
+function isSearchableField(field) {
+  return VALUE_TYPES.has(field.type);
+}
+function columnsOf(table) {
+  return table;
+}
+function tableOf(context, name) {
+  const entry = context.config[name];
+  return entry?.table ?? context.tables[name];
+}
+export function searchLikeCondition(dialect, column, pattern) {
+  const text = dialect === "postgres" ? sql`cast(${column} as text)` : sql`${column}`;
+  return sql`lower(${text}) like ${pattern} escape '\\'`;
+}
+function plainText(field, value) {
+  return field.type === "richtext" ? stripMarkup(value) : value;
+}
+function fieldTexts(field, value, defaultLocale) {
+  if (value == null || value === "") return [];
+  if (isTranslatableField(field)) {
+    return Object.entries(decodeTranslatableValue(value, defaultLocale) ?? {}).filter((pair) => typeof pair[1] === "string" && !!pair[1]).map(([locale, text]) => ({ locale, text: plainText(field, text) }));
+  }
+  if (isMultiSelect(field) && Array.isArray(value)) {
+    return [{ locale: null, text: value.map(String).join(", ") }];
+  }
+  if (typeof value === "string") return [{ locale: null, text: plainText(field, value) }];
+  return [{ locale: null, text: JSON.stringify(value) }];
+}
+function rowHits(fields, row, term, defaultLocale) {
+  const hits = [];
+  const collect = (field, value, hit) => {
+    for (const { locale, text } of fieldTexts(field, value, defaultLocale)) {
+      if (hits.length >= CMS_SEARCH_HITS_PER_ROW) return;
+      const snippet = searchSnippet(text, term);
+      if (snippet) hits.push({ ...hit, locale, snippet });
+    }
+  };
+  for (const [key, field] of Object.entries(fields)) {
+    if (hits.length >= CMS_SEARCH_HITS_PER_ROW) break;
+    if (!isSearchableField(field)) continue;
+    const value = row[key];
+    if (field.type !== "blocks") {
+      collect(field, value, { field: key, block: null, fieldLabel: field.label });
+      continue;
+    }
+    if (!Array.isArray(value)) continue;
+    value.forEach((item, index) => {
+      const block = item ? field.blocks?.[String(item.type)] : void 0;
+      if (!item || !block) return;
+      for (const [blockKey, blockField] of Object.entries(block.fields)) {
+        if (!isSearchableField(blockField)) continue;
+        collect(blockField, item[blockKey], {
+          field: key,
+          block: index,
+          fieldLabel: searchFieldPath(field.label, block.label, blockField.label)
+        });
+      }
+    });
+  }
+  return hits;
+}
+function titleOf(entry, row, defaultLocale) {
+  if (entry.kind === "single" || !entry.titleField) return null;
+  const value = row[entry.titleField];
+  if (value == null) return null;
+  if (typeof value === "object") {
+    const values = value;
+    const text = [values[defaultLocale], ...Object.values(values)].find(
+      (candidate) => typeof candidate === "string" && !!candidate
+    );
+    return text ?? null;
+  }
+  return String(value) || null;
+}
+async function tableRows(context, entry, table) {
+  const columns = columnsOf(table);
+  const conditions = Object.entries(entry.fields).filter(([key, field]) => isSearchableField(field) && Object.hasOwn(columns, key)).map(([key]) => searchLikeCondition(context.dialect, columns[key], context.pattern));
+  if (!conditions.length) return [];
+  const query = context.db.select().from(table).where(or(...conditions));
+  const ordered = columns.updatedAt ? query.orderBy(desc(columns.updatedAt)) : query;
+  return await ordered.limit(CMS_SEARCH_ROWS_PER_ENTRY);
+}
+async function pageRows(context, name, entry, table) {
+  const fields = tableOf(context, pageFieldsTableName(name));
+  const media = tableOf(context, pageMediaTableName(name));
+  if (!fields || !media) return [];
+  const pageColumns = columnsOf(table);
+  const fieldColumns = columnsOf(fields);
+  const matched = await context.db.selectDistinct({ id: fieldColumns.pageId }).from(fields).where(searchLikeCondition(context.dialect, fieldColumns.value, context.pattern)).limit(CMS_SEARCH_ROWS_PER_ENTRY);
+  const conditions = Object.entries(pageColumnFields(entry)).filter(([key, field]) => isSearchableField(field) && Object.hasOwn(pageColumns, key)).map(([key]) => searchLikeCondition(context.dialect, pageColumns[key], context.pattern));
+  if (conditions.length) {
+    matched.push(
+      ...await context.db.select({ id: pageColumns.id }).from(table).where(or(...conditions)).limit(CMS_SEARCH_ROWS_PER_ENTRY)
+    );
+  }
+  const ids = [...new Set(matched.map((row) => String(row.id)))].slice(
+    0,
+    CMS_SEARCH_ROWS_PER_ENTRY
+  );
+  if (!ids.length) return [];
+  const rows = await selectPages(context.db, context.dialect, {
+    page: table,
+    fields,
+    media
+  }).where(inArray(pageColumns.id, ids));
+  return decodePageRows(entry, rows);
+}
+function itemPath(name, entry, row) {
+  if (entry.kind === "single") return `/cms/${name}`;
+  if (entry.kind === "page") {
+    const route = pageRouteOf(entry, String(row.id));
+    return route ? `/cms/${name}/${route.key}` : null;
+  }
+  return row.id == null ? null : `/cms/${name}/${String(row.id)}`;
+}
+function entryHits(context, name, entry, rows) {
+  const { defaultLocale } = context.i18n;
+  const hits = [];
+  for (const row of rows) {
+    const path = itemPath(name, entry, row);
+    if (!path) continue;
+    const route = entry.kind === "page" ? pageRouteOf(entry, String(row.id)) : void 0;
+    const fields = route ? pageFields(entry, route.path) : entry.fields;
+    const title = route ? route.label : titleOf(entry, row, defaultLocale);
+    for (const hit of rowHits(fields, row, context.term, defaultLocale)) {
+      hits.push({
+        type: "value",
+        collection: name,
+        entryLabel: entry.label,
+        kind: entry.kind,
+        id: entry.kind === "single" ? null : String(row.id),
+        title,
+        field: hit.field,
+        fieldLabel: hit.fieldLabel,
+        locale: hit.locale,
+        snippet: hit.snippet,
+        to: cmsSearchLink(path, {
+          field: hit.field,
+          locale: hit.locale,
+          block: hit.block
+        })
+      });
+    }
+  }
+  return hits;
+}
+async function mediaHits(context) {
+  const table = context.tables.cms_media;
+  const columns = table ? columnsOf(table) : void 0;
+  if (!table || !columns?.alt || !columns.key || !columns.folder) return [];
+  const rows = await context.db.select({ key: columns.key, alt: columns.alt, folder: columns.folder }).from(table).where(searchLikeCondition(context.dialect, columns.alt, context.pattern)).limit(CMS_SEARCH_ROWS_PER_ENTRY);
+  return rows.flatMap((row) => {
+    const snippet = row.alt ? searchSnippet(row.alt, context.term) : null;
+    if (!snippet) return [];
+    const folder = row.folder ?? "";
+    return [
+      {
+        type: "media",
+        collection: null,
+        entryLabel: "Media",
+        kind: "media",
+        id: row.key,
+        title: mediaFilename(row.key),
+        field: "alt",
+        fieldLabel: "Alt text",
+        locale: null,
+        snippet,
+        to: folder ? `/cms/media?${new URLSearchParams({ folder })}` : "/cms/media"
+      }
+    ];
+  });
+}
+export async function searchCmsValues(options) {
+  const term = normalizeSearchQuery(options.query);
+  if (term.length < CMS_SEARCH_MIN_LENGTH) return { hits: [], truncated: false };
+  const context = {
+    ...options,
+    term,
+    pattern: searchLikePattern(term.toLowerCase())
+  };
+  const hits = [];
+  let truncated = false;
+  for (const [name, entry] of Object.entries(options.config)) {
+    const table = tableOf(context, name);
+    if (!table) continue;
+    const rows = entry.kind === "page" ? await pageRows(context, name, entry, table) : await tableRows(context, entry, table);
+    if (rows.length >= CMS_SEARCH_ROWS_PER_ENTRY) truncated = true;
+    hits.push(...entryHits(context, name, entry, rows));
+  }
+  const media = await mediaHits(context);
+  if (media.length >= CMS_SEARCH_ROWS_PER_ENTRY) truncated = true;
+  hits.push(...media);
+  if (hits.length > CMS_SEARCH_VALUE_LIMIT) truncated = true;
+  return { hits: hits.slice(0, CMS_SEARCH_VALUE_LIMIT), truncated };
+}
+export async function searchCms(options) {
+  const query = normalizeSearchQuery(options.query);
+  if (query.length < CMS_SEARCH_MIN_LENGTH) return { query, hits: [], truncated: false };
+  const labels = searchCmsLabels(options.config, query);
+  const values = await searchCmsValues({ ...options, query });
+  return {
+    query,
+    hits: [...labels.hits, ...values.hits],
+    truncated: labels.truncated || values.truncated
+  };
+}

package/dist/runtime/shared/search.d.ts

@@ -0,0 +1,52 @@
+import type { CmsConfig, CmsEntryKind } from './index.js';
+export declare const CMS_SEARCH_MIN_LENGTH = 2;
+export declare const CMS_SEARCH_MAX_LENGTH = 200;
+export declare const CMS_SEARCH_LABEL_LIMIT = 20;
+export declare const CMS_SEARCH_VALUE_LIMIT = 50;
+export declare const CMS_SEARCH_ROWS_PER_ENTRY = 10;
+export declare const CMS_SEARCH_HITS_PER_ROW = 5;
+export declare const CMS_SEARCH_PATH_SEPARATOR = " \u203A ";
+export type CmsSearchHitType = 'entry' | 'page' | 'tab' | 'field' | 'block' | 'value' | 'media';
+export type CmsSearchKind = CmsEntryKind | 'media';
+export interface CmsSearchSnippet {
+    before: string;
+    match: string;
+    after: string;
+}
+export interface CmsSearchHit {
+    type: CmsSearchHitType;
+    collection: string | null;
+    entryLabel: string;
+    kind: CmsSearchKind;
+    id: string | null;
+    title: string | null;
+    field: string | null;
+    fieldLabel: string | null;
+    locale: string | null;
+    snippet: CmsSearchSnippet;
+    to: string;
+}
+export interface CmsSearchResponse {
+    query: string;
+    hits: CmsSearchHit[];
+    truncated: boolean;
+}
+export interface CmsSearchFocus {
+    field?: string;
+    locale?: string | null;
+    block?: number | null;
+    tab?: string;
+}
+export declare function normalizeSearchQuery(value: string): string;
+export declare function isSearchableQuery(value: string): boolean;
+export declare function searchLikePattern(term: string): string;
+export declare function decodeHtmlEntities(value: string): string;
+export declare function stripMarkup(html: string): string;
+export declare function searchSnippet(text: string, term: string): CmsSearchSnippet | null;
+export declare function searchFieldPath(...labels: string[]): string;
+export declare function cmsSearchLink(path: string, focus?: CmsSearchFocus): string;
+export declare function readSearchFocus(query: Record<string, unknown>): CmsSearchFocus | null;
+export declare function searchCmsLabels(config: CmsConfig, query: string, limit?: number): {
+    hits: CmsSearchHit[];
+    truncated: boolean;
+};