@xleddyl/nuxt-cms 0.2.3 → 0.4.0

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

package/dist/runtime/shared/search.js

@@ -0,0 +1,207 @@
+import { entryTabs, fieldTab, pageAllFields, pageRoutes } from "./index.js";
+export const CMS_SEARCH_MIN_LENGTH = 2;
+export const CMS_SEARCH_MAX_LENGTH = 200;
+export const CMS_SEARCH_LABEL_LIMIT = 20;
+export const CMS_SEARCH_VALUE_LIMIT = 50;
+export const CMS_SEARCH_ROWS_PER_ENTRY = 10;
+export const CMS_SEARCH_HITS_PER_ROW = 5;
+export const CMS_SEARCH_PATH_SEPARATOR = " \u203A ";
+const SNIPPET_BEFORE = 40;
+const SNIPPET_AFTER = 90;
+const ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+export function normalizeSearchQuery(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, CMS_SEARCH_MAX_LENGTH);
+}
+export function isSearchableQuery(value) {
+  return normalizeSearchQuery(value).length >= CMS_SEARCH_MIN_LENGTH;
+}
+export function searchLikePattern(term) {
+  return `%${term.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+}
+export function decodeHtmlEntities(value) {
+  return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, code) => {
+    if (code[0] === "#") {
+      const point = code[1] === "x" || code[1] === "X" ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+      return Number.isFinite(point) && point > 0 && point <= 1114111 ? String.fromCodePoint(point) : entity;
+    }
+    return ENTITIES[code.toLowerCase()] ?? entity;
+  });
+}
+export function stripMarkup(html) {
+  return decodeHtmlEntities(
+    html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<\/?(p|div|li|ul|ol|h[1-6]|blockquote|pre|br|hr|tr|td|th)\b[^>]*>/gi, " ").replace(/<[^>]*>/g, "")
+  );
+}
+export function searchSnippet(text, term) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  const needle = normalizeSearchQuery(term).toLowerCase();
+  if (!needle) return null;
+  const index = normalized.toLowerCase().indexOf(needle);
+  if (index === -1) return null;
+  const end = index + needle.length;
+  const from = Math.max(0, index - SNIPPET_BEFORE);
+  const to = Math.min(normalized.length, end + SNIPPET_AFTER);
+  return {
+    before: `${from > 0 ? "\u2026" : ""}${normalized.slice(from, index).trimStart()}`,
+    match: normalized.slice(index, end),
+    after: `${normalized.slice(end, to).trimEnd()}${to < normalized.length ? "\u2026" : ""}`
+  };
+}
+export function searchFieldPath(...labels) {
+  return labels.join(CMS_SEARCH_PATH_SEPARATOR);
+}
+export function cmsSearchLink(path, focus = {}) {
+  const params = new URLSearchParams();
+  if (focus.field) params.set("field", focus.field);
+  if (focus.locale) params.set("locale", focus.locale);
+  if (focus.block != null) params.set("block", String(focus.block));
+  if (focus.tab) params.set("tab", focus.tab);
+  const query = params.toString();
+  return query ? `${path}?${query}` : path;
+}
+export function readSearchFocus(query) {
+  const text = (value) => {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === "string" && first ? first : void 0;
+  };
+  const field = text(query.field);
+  const tab = text(query.tab);
+  if (!field && !tab) return null;
+  const block = Number.parseInt(text(query.block) ?? "", 10);
+  return {
+    ...field ? { field } : {},
+    ...tab ? { tab } : {},
+    locale: text(query.locale) ?? null,
+    block: Number.isInteger(block) && block >= 0 ? block : null
+  };
+}
+function entryPath(name) {
+  return `/cms/${name}`;
+}
+function fieldLink(name, entry, key, overridePaths) {
+  if (entry.kind === "single") {
+    return { to: cmsSearchLink(entryPath(name), { field: key }), id: null, title: null };
+  }
+  if (entry.kind === "page" && !Object.hasOwn(entry.fields, key) && overridePaths.length === 1) {
+    const route = pageRoutes(entry).find((candidate) => candidate.path === overridePaths[0]);
+    if (route) {
+      return {
+        to: cmsSearchLink(`${entryPath(name)}/${route.key}`, { field: key }),
+        id: route.key,
+        title: route.label
+      };
+    }
+  }
+  return { to: entryPath(name), id: null, title: null };
+}
+function overridePathsOf(entry, key) {
+  return Object.entries(entry.overrides ?? {}).filter(([, fields]) => !!fields[key]).map(([path]) => path);
+}
+function blockCandidates(key, field, link) {
+  const candidates = [];
+  for (const block of Object.values(field.blocks ?? {})) {
+    candidates.push({
+      type: "block",
+      ...link,
+      field: key,
+      fieldLabel: searchFieldPath(field.label, block.label),
+      texts: [block.label]
+    });
+    for (const blockField of Object.values(block.fields)) {
+      candidates.push({
+        type: "field",
+        ...link,
+        field: key,
+        fieldLabel: searchFieldPath(field.label, block.label, blockField.label),
+        texts: [blockField.label]
+      });
+    }
+  }
+  return candidates;
+}
+function labelCandidates(name, entry) {
+  const candidates = [
+    { type: "entry", texts: [entry.label], to: entryPath(name) }
+  ];
+  if (entry.kind === "page") {
+    for (const route of pageRoutes(entry)) {
+      candidates.push({
+        type: "page",
+        id: route.key,
+        title: route.label,
+        texts: [route.label, route.path],
+        to: `${entryPath(name)}/${route.key}`
+      });
+    }
+  }
+  for (const tab of entryTabs(entry)) {
+    candidates.push({
+      type: "tab",
+      fieldLabel: tab.label,
+      texts: [tab.label],
+      to: entry.kind === "single" ? cmsSearchLink(entryPath(name), { tab: tab.id }) : entryPath(name)
+    });
+  }
+  const fields = entry.kind === "page" ? pageAllFields(entry) : entry.fields;
+  const tabs = entryTabs(entry);
+  for (const [key, field] of Object.entries(fields)) {
+    const link = fieldLink(name, entry, key, overridePathsOf(entry, key));
+    candidates.push({
+      type: "field",
+      ...link,
+      field: key,
+      fieldLabel: tabs.length ? searchFieldPath(
+        tabs.find((tab) => tab.id === fieldTab(field, tabs))?.label ?? "",
+        field.label
+      ) : field.label,
+      texts: [field.label]
+    });
+    if (field.type === "blocks") candidates.push(...blockCandidates(key, field, link));
+  }
+  return candidates;
+}
+export function searchCmsLabels(config, query, limit = CMS_SEARCH_LABEL_LIMIT) {
+  const term = normalizeSearchQuery(query);
+  if (term.length < CMS_SEARCH_MIN_LENGTH) return { hits: [], truncated: false };
+  const needle = term.toLowerCase();
+  const scored = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, entry] of Object.entries(config)) {
+    for (const candidate of labelCandidates(name, entry)) {
+      const text = candidate.texts.find((value) => value.toLowerCase().includes(needle));
+      if (!text) continue;
+      const snippet = searchSnippet(text, term);
+      if (!snippet) continue;
+      const identity = [candidate.type, name, candidate.fieldLabel ?? "", candidate.to].join(
+        "\0"
+      );
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      scored.push({
+        score: text.toLowerCase().startsWith(needle) ? 0 : 1,
+        hit: {
+          type: candidate.type,
+          collection: name,
+          entryLabel: entry.label,
+          kind: entry.kind,
+          id: candidate.id ?? null,
+          title: candidate.title ?? null,
+          field: candidate.field ?? null,
+          fieldLabel: candidate.fieldLabel ?? null,
+          locale: null,
+          snippet,
+          to: candidate.to
+        }
+      });
+    }
+  }
+  const sorted = scored.map((item, index) => ({ ...item, index })).sort((a, b) => a.score - b.score || a.index - b.index).map((item) => item.hit);
+  return { hits: sorted.slice(0, limit), truncated: sorted.length > limit };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "Lightweight CMS that ships with your Nuxt app: runs on the Nitro server, content types defined in code, /cms admin panel, GraphQL API, SQLite or Postgres. No external CMS needed!",
   "license": "MIT",
   "author": "Edoardo Alberti (https://github.com/xleddyl)",
@@ -124,6 +124,6 @@
     "test:docker": "vitest run --config test/docker/vitest.config.ts",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "format": "prettier --write \"**/*.{ts,tsx,js,jsx,md,html,json,sql,vue}\" --log-level error",
-    "release": "sh -c 'changelogen --release --no-github ${1:+--$1} && git push origin main --follow-tags' --"
+    "release": "node scripts/release.mjs"
   }
 }