@karibsen/eponyme 0.1.0

package/dist/runtime/utils/validate-eponyme-data.js

@@ -0,0 +1,204 @@
+import { isArrayItemFieldDefinition } from "./get-field-default-value.js";
+import { isFieldVisible } from "./is-field-visible.js";
+const urlPattern = /^https?:\/\//i;
+const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+const colorPattern = /^#(?:[\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i;
+const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createErrors() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function addError(errors, path, message) {
+  (errors[path] ??= []).push(message);
+}
+function countErrorsUnder(errors, path) {
+  const prefix = `${path}.`;
+  return Object.entries(errors).filter(([key]) => key === path || key.startsWith(prefix)).reduce((total, [, messages]) => total + messages.length, 0);
+}
+function validateField(path, definition, value, errors, mode, context) {
+  if (!isFieldVisible(definition.options, context)) return;
+  const errorsBefore = countErrorsUnder(errors, path);
+  validateFieldRules(path, definition, value, errors, mode, context);
+  if (countErrorsUnder(errors, path) !== errorsBefore || value === void 0 || value === null || !definition.options.validate) return;
+  try {
+    const result = definition.options.validate(value, context);
+    if (typeof result === "string") addError(errors, path, result);
+    else if (Array.isArray(result)) result.forEach((message) => addError(errors, path, message));
+  } catch {
+    addError(errors, path, "Custom validation failed.");
+  }
+}
+function validateFieldRules(name, definition, value, errors, mode, _context) {
+  const { options } = definition;
+  if (value === void 0 || value === null) {
+    if (mode === "publish" && options.required) addError(errors, name, "This field is required.");
+    return;
+  }
+  if (definition.type === "section") {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      addError(errors, name, "Must be an object.");
+      return;
+    }
+    const sectionData = value;
+    for (const sectionField of Object.keys(sectionData)) {
+      if (!definition.options.fields[sectionField]) addError(errors, `${name}.${sectionField}`, "Unknown field.");
+    }
+    for (const [sectionField, sectionDefinition] of Object.entries(definition.options.fields))
+      validateField(`${name}.${sectionField}`, sectionDefinition, sectionData[sectionField], errors, mode, sectionData);
+    return;
+  }
+  if (definition.type === "tabs") {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      addError(errors, name, "Must be an object.");
+      return;
+    }
+    const tabsData = value;
+    for (const tabName of Object.keys(tabsData)) {
+      if (!definition.options.tabs[tabName]) addError(errors, `${name}.${tabName}`, "Unknown tab.");
+    }
+    for (const [tabName, tabDefinition] of Object.entries(definition.options.tabs)) {
+      const tabValue = tabsData[tabName];
+      if (!tabValue || typeof tabValue !== "object" || Array.isArray(tabValue)) {
+        addError(errors, `${name}.${tabName}`, "Must be an object.");
+        continue;
+      }
+      const tabData = tabValue;
+      for (const tabField of Object.keys(tabData)) {
+        if (!tabDefinition.fields[tabField]) addError(errors, `${name}.${tabName}.${tabField}`, "Unknown field.");
+      }
+      for (const [tabField, fieldDefinition] of Object.entries(tabDefinition.fields))
+        validateField(`${name}.${tabName}.${tabField}`, fieldDefinition, tabData[tabField], errors, mode, tabData);
+    }
+    return;
+  }
+  if (definition.type === "checkboxGroup") {
+    if (!Array.isArray(value)) {
+      addError(errors, name, "Must be an array.");
+      return;
+    }
+    if (mode === "publish" && definition.options.required && value.length === 0) addError(errors, name, "This field is required.");
+    if (mode === "publish" && definition.options.minItems !== void 0 && value.length < definition.options.minItems) addError(errors, name, `Must contain at least ${definition.options.minItems} items.`);
+    if (definition.options.maxItems !== void 0 && value.length > definition.options.maxItems) addError(errors, name, `Must contain at most ${definition.options.maxItems} items.`);
+    if (value.some((item) => typeof item !== "string" || !definition.options.options.some((option) => option.value === item)))
+      addError(errors, name, "Must contain only available options.");
+    return;
+  }
+  if (definition.type === "array") {
+    if (!Array.isArray(value)) {
+      addError(errors, name, "Must be an array.");
+      return;
+    }
+    if (mode === "publish" && options.required && value.length === 0) addError(errors, name, "This field is required.");
+    if (mode === "publish" && definition.options.minItems !== void 0 && value.length < definition.options.minItems) addError(errors, name, `Must contain at least ${definition.options.minItems} items.`);
+    if (definition.options.maxItems !== void 0 && value.length > definition.options.maxItems) addError(errors, name, `Must contain at most ${definition.options.maxItems} items.`);
+    value.forEach((item, index) => {
+      if (!isArrayItemFieldDefinition(definition.options.of)) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+          addError(errors, `${name}.${index}`, "Must be an object.");
+          return;
+        }
+        const itemData = item;
+        for (const itemField of Object.keys(itemData)) {
+          if (!definition.options.of[itemField]) addError(errors, `${name}.${index}.${itemField}`, "Unknown field.");
+        }
+        for (const [itemField, itemDefinition] of Object.entries(definition.options.of))
+          validateField(`${name}.${index}.${itemField}`, itemDefinition, itemData[itemField], errors, mode, itemData);
+        return;
+      }
+      validateField(`${name}.${index}`, definition.options.of, item, errors, mode, {});
+    });
+    return;
+  }
+  if (definition.type === "number") {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      addError(errors, name, "Must be a number.");
+      return;
+    }
+    if (definition.options.min !== void 0 && value < definition.options.min) addError(errors, name, `Must be at least ${definition.options.min}.`);
+    if (definition.options.max !== void 0 && value > definition.options.max) addError(errors, name, `Must be at most ${definition.options.max}.`);
+    return;
+  }
+  if (definition.type === "boolean") {
+    if (typeof value !== "boolean") addError(errors, name, "Must be a boolean.");
+    return;
+  }
+  if (definition.type === "url") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      addError(errors, name, "Must be a link.");
+      return;
+    }
+    const link = value;
+    if (typeof link.href !== "string" || !["internal", "external"].includes(String(link.type)) || typeof link.openInNewTab !== "boolean") {
+      addError(errors, name, "Must be a valid link.");
+      return;
+    }
+    const href = link.href.trim();
+    if (mode === "publish" && options.required && !href) addError(errors, name, "This field is required.");
+    if (!href) return;
+    if (link.type === "external" && !urlPattern.test(href)) addError(errors, name, "External links must be HTTP(S) URLs.");
+    if (link.type === "internal" && !href.startsWith("/") && !href.startsWith("#")) addError(errors, name, "Internal links must start with / or #.");
+    return;
+  }
+  if (typeof value !== "string") {
+    addError(errors, name, "Must be a string.");
+    return;
+  }
+  const normalized = value.trim();
+  const normalizedContent = definition.type === "richText" ? getRichTextContent(normalized) : normalized;
+  if (mode === "publish" && options.required && !normalizedContent) addError(errors, name, "This field is required.");
+  if (mode === "draft" && !normalizedContent) return;
+  if (definition.type === "image" && normalized && !urlPattern.test(normalized)) addError(errors, name, "Must be an HTTP(S) URL.");
+  if (definition.type === "image") return;
+  if (definition.type === "select" || definition.type === "radio") {
+    if (normalized && !definition.options.options.some((option) => option.value === value)) addError(errors, name, "Must be one of the available options.");
+    return;
+  }
+  if (definition.type === "date") {
+    const timestamp = Date.parse(`${normalized}T00:00:00Z`);
+    const isValid = datePattern.test(normalized) && !Number.isNaN(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === normalized;
+    if (normalized && !isValid) addError(errors, name, "Must be a valid date.");
+    if (definition.options.min && normalized < definition.options.min) addError(errors, name, `Must be on or after ${definition.options.min}.`);
+    if (definition.options.max && normalized > definition.options.max) addError(errors, name, `Must be on or before ${definition.options.max}.`);
+    return;
+  }
+  if (definition.type === "color") {
+    if (normalized && !colorPattern.test(normalized)) addError(errors, name, "Must be a valid hex color.");
+    return;
+  }
+  if (definition.type === "slug") {
+    if (normalized && !slugPattern.test(normalized)) addError(errors, name, "Must contain only lowercase letters, numbers and single hyphens.");
+    if (mode === "publish" && definition.options.minLength !== void 0 && value.length < definition.options.minLength) addError(errors, name, `Must contain at least ${definition.options.minLength} characters.`);
+    if (definition.options.maxLength !== void 0 && value.length > definition.options.maxLength) addError(errors, name, `Must contain at most ${definition.options.maxLength} characters.`);
+    return;
+  }
+  if (definition.type === "richText") {
+    if (mode === "publish" && definition.options.minLength !== void 0 && normalizedContent.length < definition.options.minLength) addError(errors, name, `Must contain at least ${definition.options.minLength} characters.`);
+    if (definition.options.maxLength !== void 0 && normalizedContent.length > definition.options.maxLength) addError(errors, name, `Must contain at most ${definition.options.maxLength} characters.`);
+    return;
+  }
+  if (mode === "publish" && definition.options.minLength !== void 0 && value.length < definition.options.minLength) addError(errors, name, `Must contain at least ${definition.options.minLength} characters.`);
+  if (definition.options.maxLength !== void 0 && value.length > definition.options.maxLength) addError(errors, name, `Must contain at most ${definition.options.maxLength} characters.`);
+  if (definition.options.regex && !definition.options.regex.test(value)) addError(errors, name, "Has an invalid format.");
+  const [localPart, domain, ...extraParts] = normalized.split("@");
+  if ((definition.type === "email" || definition.options.email) && normalized && (!localPart || !domain?.includes(".") || extraParts.length)) addError(errors, name, "Must be a valid email address.");
+  if (definition.options.url && normalized && !urlPattern.test(normalized)) addError(errors, name, "Must be an HTTP(S) URL.");
+}
+function getRichTextContent(value) {
+  return value.replace(/<br\s*\/?>/gi, " ").replace(/<\/p>|<\/h[1-6]>|<\/li>|<\/blockquote>/gi, " ").replace(/<[^>]+>/g, "").replace(/&nbsp;|&#160;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();
+}
+export function validateEponymePatch(schema, payload, data, mode = "publish") {
+  const errors = createErrors();
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { _form: ["Body must be an object."] };
+  const context = data ?? payload;
+  for (const [name, value] of Object.entries(payload)) {
+    const definition = schema[name];
+    if (!definition) addError(errors, name, "Unknown field.");
+    else validateField(name, definition, value, errors, mode, context);
+  }
+  return errors;
+}
+export function validateEponymeData(schema, data, mode = "publish") {
+  const errors = createErrors();
+  for (const [name, definition] of Object.entries(schema))
+    validateField(name, definition, data[name], errors, mode, data);
+  return errors;
+}

package/dist/types.d.mts

@@ -0,0 +1,11 @@
+export { type collection, type defineEponymeConfig, type form } from './eponyme.mjs'
+
+export { type field, type today } from '../dist/runtime/fields/index.js'
+
+export { type EPONYME_ROLES, type canEditEponyme, type isEponymeRole } from '../dist/runtime/types/auth.js'
+
+export { type ArrayFieldDefinition, type ArrayFieldOptions, type ArrayItemDefinition, type ArrayItemFieldDefinition, type ArrayItemSchema, type ArrayItemValue, type BooleanFieldDefinition, type BooleanFieldOptions, type CheckboxGroupFieldDefinition, type CheckboxGroupFieldOptions, type CollectionSlugField, type ColorFieldDefinition, type ColorFieldOptions, type DateFieldDefinition, type DateFieldOptions, type EmailFieldDefinition, type EmailFieldOptions, type EponymeAuthSession, type EponymeAuthUser, type EponymeCollectionDataByName, type EponymeCollectionDefinition, type EponymeCollectionDefinitionBase, type EponymeCollectionName, type EponymeCollectionOptions, type EponymeConfig, type EponymeData, type EponymeDataByName, type EponymeFormDataByName, type EponymeFormDefinition, type EponymeFormDefinitionBase, type EponymeFormFieldDefinition, type EponymeFormMode, type EponymeFormName, type EponymeFormOptions, type EponymeFormSchema, type EponymeManagedUserResult, type EponymeName, type EponymeRole, type EponymeSchema, type FieldDefinition, type FieldValidationResult, type FieldValidator, type FieldVisibilityCondition, type ImageFieldDefinition, type ImageFieldOptions, type NumberFieldDefinition, type NumberFieldOptions, type RadioFieldDefinition, type RadioFieldOptions, type RichTextFieldDefinition, type RichTextFieldOptions, type SectionFieldDefinition, type SectionFieldOptions, type SectionItemFieldDefinition, type SectionItemValue, type SectionSchema, type SectionValue, type SelectFieldDefinition, type SelectFieldOptions, type SelectOption, type SlugFieldDefinition, type SlugFieldOptions, type StringFieldDefinition, type StringFieldOptions, type TabDefinition, type TabFieldDefinition, type TabFieldOptions, type TabsSchema, type TabsValue, type TextareaFieldDefinition, type TextareaFieldOptions, type TodayDateDefault, type UrlFieldDefinition, type UrlFieldOptions, type UrlType, type UrlValue } from '../dist/runtime/types/index.js'
+
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@karibsen/eponyme",
+  "version": "0.1.0",
+  "description": "A lightweight, type-safe content manager for Nuxt.",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "pnpm@10.33.4",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "cms",
+    "content",
+    "prisma",
+    "postgresql",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/karibsen-studio/eponyme.git"
+  },
+  "homepage": "https://github.com/karibsen-studio/eponyme#readme",
+  "bugs": {
+    "url": "https://github.com/karibsen-studio/eponyme/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./config": {
+      "types": "./dist/eponyme.d.mts",
+      "import": "./dist/eponyme.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev --cwd playground",
+    "dev:build": "nuxt build --cwd playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare --cwd playground",
+    "release": "npm run lint && npm run test && npm run test:types && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@iconify-json/mingcute": "^1.2.7",
+    "@nuxt/icon": "^2.3.1",
+    "@nuxt/kit": "^4.4.8",
+    "@tailwindcss/vite": "^4.1.12",
+    "@tanstack/vue-table": "^8.21.3",
+    "@tiptap/extension-image": "^3.29.2",
+    "@tiptap/extension-placeholder": "^3.28.0",
+    "@tiptap/starter-kit": "^3.28.0",
+    "@tiptap/vue-3": "^3.28.0",
+    "@vueuse/core": "^14.3.0",
+    "@vueuse/integrations": "^14.3.0",
+    "picocolors": "^1.1.1",
+    "reka-ui": "^2.10.1",
+    "slugify": "^1.6.9",
+    "sortablejs": "^1.15.7",
+    "tailwindcss": "^4.1.12",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.2.4",
+    "@nuxt/eslint-config": "^1.15.2",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.8",
+    "@nuxt/test-utils": "^4.0.3",
+    "@types/node": "latest",
+    "@types/sortablejs": "^1.15.9",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.4.1",
+    "nuxt": "^4.4.8",
+    "typescript": "~6.0.3",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.1.8",
+    "vue-tsc": "^3.3.3"
+  }
+}