@karibsen/eponyme 0.7.0 → 0.8.0

package/dist/runtime/components/ui/EPTagsInput.vue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Chips plus a row of suggestion buttons, knowing nothing about Eponyme.
+ *
+ * The suggestions the developer configured are not a filtered autocomplete list: they're
+ * rendered as standing buttons below the input so an editor can see and click them directly,
+ * with no typing or listbox navigation required. `TagsInputRoot` still owns the chips, their
+ * keyboard handling and the delete buttons.
+ */
+type __VLS_Props = {
+    modelValue?: string[];
+    /** Rendered as clickable buttons below the input, minus the ones already picked. */
+    suggestions?: readonly string[];
+    /** Whether a value outside `suggestions` may be added. */
+    allowCustom?: boolean;
+    placeholder?: string;
+    max?: number;
+    required?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/composables/useEponymeCollection.d.ts

@@ -1,15 +1,27 @@
 import type { ComputedRef, Ref } from 'vue';
 import type eponymeConfig from '#eponyme/config';
-import type { EponymeCollectionDataByName, EponymeCollectionName } from '../types/index.js';
+import type { EponymeCollectionDataByName, EponymeCollectionFilter, EponymeCollectionName } from '../types/index.js';
 import type { EponymeCollectionEntry, EponymeSortDirection, EponymeStatus, EponymeVersionSelector } from '../server/services/eponyme-store.js';
 type ConfigCollectionName = EponymeCollectionName<typeof eponymeConfig>;
 /** Sortable keys: the entry metadata plus every field of the collection. */
 export type EponymeCollectionSortKey<Name extends ConfigCollectionName> = 'updatedAt' | 'publishedAt' | 'title' | 'slug' | (keyof EponymeCollectionDataByName<typeof eponymeConfig, Name> & string);
+/**
+ * The `where` a collection accepts: only the fields stored in a form the index can compare,
+ * each with the values that field can actually hold. The server rejects anything else, so
+ * the two agree rather than one silently widening the other.
+ */
+export type EponymeCollectionFilterInput<Name extends ConfigCollectionName> = EponymeCollectionFilter<typeof eponymeConfig, Name>;
 export interface UseEponymeCollectionOptions<Name extends ConfigCollectionName> {
     take?: number;
     skip?: number;
     orderBy?: EponymeCollectionSortKey<Name>;
     order?: EponymeSortDirection;
+    /**
+     * Keeps only the entries matching every key. A list of values matches any of them; `not`
+     * excludes; `contains` matches a substring; and `gte`/`lte`/`gt`/`lt` compare as text,
+     * which is exact for `field.date()`, pinned by validation to `YYYY-MM-DD`.
+     */
+    where?: EponymeCollectionFilterInput<Name>;
 }
 export interface UseEponymeCollectionResult<Data extends Record<string, unknown>> {
     entries: ComputedRef<EponymeCollectionEntry<Data>[]>;

package/dist/runtime/composables/useEponymeCollection.js

@@ -3,18 +3,43 @@ import { useEventListener } from "@vueuse/core";
 import { computed } from "vue";
 import { readPreviewQuery, readPreviewVersion } from "../utils/preview.js";
 import { cacheForPublicRead } from "../utils/hydration-cache.js";
+function serializeFilter(where) {
+  const query = {};
+  const parts = [];
+  const write = (name, values) => {
+    if (!values.length) return;
+    query[name] = values;
+    parts.push(`${name}=${values.join("|")}`);
+  };
+  const list = (value) => (Array.isArray(value) ? value : [value]).map(String).filter(Boolean);
+  for (const key of Object.keys(where ?? {}).sort()) {
+    const condition = where[key];
+    if (condition === void 0 || condition === null) continue;
+    if (typeof condition !== "object" || Array.isArray(condition)) {
+      write(`where[${key}]`, list(condition));
+      continue;
+    }
+    for (const operator of Object.keys(condition).sort()) {
+      write(`where[${key}][${operator}]`, list(condition[operator]));
+    }
+  }
+  return { query, key: parts.join(",") };
+}
 export function useEponymeCollection(name, options = {}) {
   const requestFetch = useRequestFetch();
+  const filter = serializeFilter(options.where);
   const query = {
     take: options.take,
     skip: options.skip,
     orderBy: options.orderBy,
-    order: options.order
+    order: options.order,
+    ...filter.query
   };
   const result = useAsyncData(
-    // The options belong in the key, otherwise two differently sorted calls to the
-    // same collection would share one cache entry.
-    `eponyme:collection:public:${name}:${options.take ?? ""}:${options.skip ?? ""}:${options.orderBy ?? ""}:${options.order ?? ""}`,
+    // Every option belongs in the key, otherwise two differently sorted — or differently
+    // filtered — calls to the same collection would share one cache entry and one would
+    // silently answer with the other's results.
+    `eponyme:collection:public:${name}:${options.take ?? ""}:${options.skip ?? ""}:${options.orderBy ?? ""}:${options.order ?? ""}:${filter.key}`,
     // Always the published listing, which is publicly cacheable: the browser cache may answer it.
     () => requestFetch(`/api/eponyme-collections/${name}`, { query }),
     { getCachedData: cacheForPublicRead(true) }

package/dist/runtime/fields/index.d.ts

@@ -13,6 +13,7 @@ import { section } from './section.js';
 import { select } from './select.js';
 import { slug } from './slug.js';
 import { string } from './string.js';
+import { tags } from './tags.js';
 import { tab } from './tab.js';
 import { textarea } from './textarea.js';
 import { url } from './url.js';
@@ -30,6 +31,7 @@ export declare const field: {
     select: typeof select;
     radio: typeof radio;
     checkboxGroup: typeof checkboxGroup;
+    tags: typeof tags;
     date: typeof date;
     color: typeof color;
     array: typeof array;

package/dist/runtime/fields/index.js

@@ -13,8 +13,9 @@ import { section } from "./section.js";
 import { select } from "./select.js";
 import { slug } from "./slug.js";
 import { string } from "./string.js";
+import { tags } from "./tags.js";
 import { tab } from "./tab.js";
 import { textarea } from "./textarea.js";
 import { url } from "./url.js";
-export const field = { string, slug, email, phone, url, textarea, richText, number, boolean, image, select, radio, checkboxGroup, date, color, array, section, tab };
+export const field = { string, slug, email, phone, url, textarea, richText, number, boolean, image, select, radio, checkboxGroup, tags, date, color, array, section, tab };
 export { today };

package/dist/runtime/fields/tags.d.ts

@@ -0,0 +1,6 @@
+import type { TagsFieldDefinition, TagsFieldOptions } from '../types/field.js';
+/**
+ * The whole options object is the type parameter, so the literals an author writes —
+ * the suggestions and `allowCustom` — survive into the value type. See `TagsValueOf`.
+ */
+export declare function tags<const O extends TagsFieldOptions>(options?: O): TagsFieldDefinition<O>;

package/dist/runtime/fields/tags.js

@@ -0,0 +1,3 @@
+export function tags(options = {}) {
+  return { type: "tags", options };
+}

package/dist/runtime/pages/EponymeIndexPage.vue

@@ -104,9 +104,6 @@ function closePreview() {
     <section class="ep:mx-auto ep:w-full ep:max-w-3xl ep:px-6 ep:py-8 ep:md:px-10 ep:md:py-12">
       <div class="ep:flex ep:flex-wrap ep:items-start ep:justify-between ep:gap-4">
         <div>
-          <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
-            Eponyme
-          </p>
           <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
             Content entries
           </h1>

package/dist/runtime/server/api/eponyme-collections/[path].get.js

@@ -4,12 +4,50 @@ import { requireEponymeUser } from "../../utils/auth.js";
 import { getEponymeCacheTags, setEponymePublicCache } from "../../utils/eponyme-cache.js";
 import { interpolateEponymeContent } from "../../utils/eponyme-variables.js";
 const MAX_TAKE = 200;
+const OPERATORS = ["gte", "lte", "gt", "lt", "contains", "in", "not"];
+const LIST_OPERATORS = /* @__PURE__ */ new Set(["in", "not"]);
+const FILTER_KEY = /^where\[([^\]]+)\](?:\[([^\]]+)\])?$/;
 function readCount(raw, min, max) {
   if (raw === void 0 || raw === "") return void 0;
   const value = Number(raw);
   if (!Number.isFinite(value)) return void 0;
   return Math.min(max, Math.max(min, Math.trunc(value)));
 }
+function readFilter(query, allowed) {
+  const where = {};
+  for (const [rawKey, rawValue] of Object.entries(query)) {
+    const match = FILTER_KEY.exec(rawKey);
+    if (!match) continue;
+    const [, key, operator] = match;
+    if (!allowed?.includes(key)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `Unknown filter key "${key}". Available keys: ${allowed?.join(", ") || "none"}.`
+      });
+    }
+    if (operator === void 0) {
+      const values = (Array.isArray(rawValue) ? rawValue : [rawValue]).map(String).filter(Boolean);
+      if (values.length) where[key] = values.length === 1 ? values[0] : values;
+      continue;
+    }
+    if (!OPERATORS.includes(operator)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `Unknown filter operator "${operator}". Available operators: ${OPERATORS.join(", ")}.`
+      });
+    }
+    const existing = where[key];
+    const operators = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+    if (LIST_OPERATORS.has(operator)) {
+      const values = (Array.isArray(rawValue) ? rawValue : [rawValue]).map(String).filter(Boolean);
+      if (values.length) operators[operator] = values;
+    } else {
+      operators[operator] = String(Array.isArray(rawValue) ? rawValue[0] : rawValue);
+    }
+    where[key] = operators;
+  }
+  return Object.keys(where).length ? where : void 0;
+}
 export default defineEventHandler(async (event) => {
   const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
   const query = getQuery(event);
@@ -33,7 +71,8 @@ export default defineEventHandler(async (event) => {
     take: readCount(query.take, 1, MAX_TAKE),
     skip: readCount(query.skip, 0, Number.MAX_SAFE_INTEGER),
     orderBy,
-    order: query.order === "asc" ? "asc" : query.order === "desc" ? "desc" : void 0
+    order: query.order === "asc" ? "asc" : query.order === "desc" ? "desc" : void 0,
+    where: readFilter(query, service.collectionFilterKeys(name))
   });
   if (!page) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
   return query.raw ? page : interpolateEponymeContent(page);

package/dist/runtime/server/plugins/eponyme-sync.js

@@ -1,4 +1,4 @@
-import { defineNitroPlugin } from "nitropack/runtime";
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
 import { useEponymeAuthService } from "../services/eponyme-auth-service.js";
 import { useEponymeService } from "../services/eponyme-service.js";
 export default defineNitroPlugin(async () => {
@@ -11,4 +11,14 @@ export default defineNitroPlugin(async () => {
     );
   }
   await useEponymeService().syncAll();
+  const content = useRuntimeConfig().eponymeContent;
+  if (content?.autoReindex === false) return;
+  try {
+    await useEponymeService().syncIndexState();
+  } catch (error) {
+    throw new Error(
+      "[Eponyme] Index rebuild failed. Apply the EponymeEntryIndex and EponymeIndexState Prisma migrations before starting the application, or set `eponyme.autoReindex: false` to start without it and run `reindexEponymeEntries()` by hand.",
+      { cause: error }
+    );
+  }
 });

package/dist/runtime/server/services/eponyme-form-store.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { normalizeEponymePhones } from "../../utils/normalize-eponyme-phones.js";
+import { normalizeEponymeValues } from "../../utils/normalize-eponyme-values.js";
 import { getEponymeForms } from "../../utils/get-eponyme-schemas.js";
 import { validateEponymeData } from "../../utils/validate-eponyme-data.js";
 const DEFAULT_PER_PAGE = 25;
@@ -41,7 +41,7 @@ export class EponymeFormService {
     const unknownKeys = Object.keys(submitted).filter((key) => !(key in definition.fields));
     if (unknownKeys.length)
       return { errors: Object.fromEntries(unknownKeys.map((key) => [key, ["Unknown field."]])) };
-    const rest = normalizeEponymePhones(definition.fields, submitted);
+    const rest = normalizeEponymeValues(definition.fields, submitted);
     const errors = validateEponymeData(definition.fields, rest, "publish");
     if (Object.keys(errors).length) return { errors };
     return { data: rest };