@xleddyl/nuxt-cms 0.4.1 → 0.4.3

package/dist/runtime/shared/transfer.js

@@ -0,0 +1,256 @@
+import { isCollectionKind, isMultiSelect, isTranslatableField, selectOptionLabel } from "./index.js";
+export const TRANSFER_FORMATS = ["json", "csv"];
+export const IMPORT_MODES = ["create", "upsert"];
+export const IMPORT_MAX_BYTES = 5 * 1024 * 1024;
+export const IMPORT_MAX_ROWS = 2e3;
+export const IMPORT_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+export const TRANSFER_ID_KEY = "id";
+export const TRANSFER_TIMESTAMP_KEYS = ["createdAt", "updatedAt"];
+const STATUS_KEY = "status";
+const CSV_BOM = "\uFEFF";
+function hasStatus(entry) {
+  return isCollectionKind(entry) && !!entry.drafts && !Object.hasOwn(entry.fields, STATUS_KEY);
+}
+export function canTransferCsv(entry) {
+  return Object.values(entry.fields).every(
+    (field) => field.type !== "blocks" && !(field.type === "relation" && field.cardinality === "many-to-many")
+  );
+}
+export function transferKeys(entry) {
+  return [
+    TRANSFER_ID_KEY,
+    ...Object.keys(entry.fields),
+    ...hasStatus(entry) ? [STATUS_KEY] : [],
+    ...TRANSFER_TIMESTAMP_KEYS
+  ];
+}
+export function exportRow(entry, row) {
+  return Object.fromEntries(
+    transferKeys(entry).filter((key) => Object.hasOwn(row, key) || Object.hasOwn(entry.fields, key)).map((key) => [key, row[key] ?? null])
+  );
+}
+export function exportFileName(name, format, now = /* @__PURE__ */ new Date()) {
+  return `${name}-${now.toISOString().slice(0, 10)}.${format}`;
+}
+function isLocalized(field, i18n) {
+  return isTranslatableField(field) && i18n.locales.length > 0;
+}
+export function csvColumns(entry, i18n) {
+  return transferKeys(entry).flatMap((key) => {
+    const field = entry.fields[key];
+    if (field && isLocalized(field, i18n)) return i18n.locales.map((locale) => `${key}.${locale}`);
+    return [key];
+  });
+}
+export function encodeCsvCell(value) {
+  return /[",\r\n]|^\s|\s$/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+export function encodeCsv(rows) {
+  return rows.map((row) => row.map(encodeCsvCell).join(",")).join("\r\n") + "\r\n";
+}
+export function parseCsv(text) {
+  const input = text.startsWith(CSV_BOM) ? text.slice(1) : text;
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  let index = 0;
+  while (index < input.length) {
+    const char = input[index];
+    if (quoted) {
+      if (char === '"' && input[index + 1] === '"') {
+        cell += '"';
+        index += 2;
+        continue;
+      }
+      if (char === '"') quoted = false;
+      else cell += char;
+      index++;
+      continue;
+    }
+    if (char === '"' && cell === "") {
+      quoted = true;
+    } else if (char === ",") {
+      row.push(cell);
+      cell = "";
+    } else if (char === "\n" || char === "\r") {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+      if (char === "\r" && input[index + 1] === "\n") index++;
+    } else {
+      cell += char;
+    }
+    index++;
+  }
+  if (quoted) throw new Error("A quoted cell is not closed");
+  if (cell !== "" || row.length) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.filter((cells) => cells.some((value) => value !== ""));
+}
+function csvCellText(field, value) {
+  if (value === null || value === void 0) return "";
+  if (field?.type === "json" || isMultiSelectField(field)) return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function isMultiSelectField(field) {
+  return !!field && isMultiSelect(field);
+}
+export function entryRowsToCsv(entry, rows, i18n) {
+  const keys = transferKeys(entry);
+  const lines = rows.map(
+    (row) => keys.flatMap((key) => {
+      const field = entry.fields[key];
+      if (field && isLocalized(field, i18n)) {
+        const value = row[key];
+        const values = value && typeof value === "object" ? value : typeof value === "string" && value ? { [i18n.defaultLocale]: value } : {};
+        return i18n.locales.map((locale) => csvCellText(void 0, values[locale]));
+      }
+      return [csvCellText(field, row[key])];
+    })
+  );
+  return CSV_BOM + encodeCsv([csvColumns(entry, i18n), ...lines]);
+}
+const TRUE_VALUES = ["true", "1", "yes"];
+const FALSE_VALUES = ["false", "0", "no"];
+export function csvCellValue(field, text) {
+  if (text === "") return { value: null };
+  if (field.type === "number") {
+    const number = Number(text.trim());
+    return text.trim() && Number.isFinite(number) ? { value: number } : { error: "Not a number" };
+  }
+  if (field.type === "boolean") {
+    const lower = text.trim().toLowerCase();
+    if (TRUE_VALUES.includes(lower)) return { value: true };
+    if (FALSE_VALUES.includes(lower)) return { value: false };
+    return { error: "Not a boolean (true or false)" };
+  }
+  if (field.type === "json" || isMultiSelect(field)) {
+    try {
+      return { value: JSON.parse(text) };
+    } catch {
+      return { error: "Invalid JSON" };
+    }
+  }
+  return { value: text };
+}
+function rowTooMany(count) {
+  return `The file has ${count} rows; the limit is ${IMPORT_MAX_ROWS}`;
+}
+export function csvImportSource(entry, text, i18n) {
+  let table;
+  try {
+    table = parseCsv(text);
+  } catch (error) {
+    return { rows: [], errors: [error.message] };
+  }
+  const [header, ...lines] = table;
+  if (!header) return { rows: [], errors: ["The file has no header row"] };
+  const names = header.map((name) => name.trim());
+  const known = new Set(csvColumns(entry, i18n));
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (!known.has(name)) errors.push(`Unknown column '${name}'`);
+    else if (seen.has(name)) errors.push(`Column '${name}' appears twice`);
+    seen.add(name);
+  }
+  if (lines.length > IMPORT_MAX_ROWS) errors.push(rowTooMany(lines.length));
+  if (errors.length) return { rows: [], errors };
+  const rows = lines.map((cells, position) => {
+    const index = position + 1;
+    const issues = [];
+    if (cells.length !== names.length) {
+      issues.push({
+        path: "",
+        message: `Expected ${names.length} cells, found ${cells.length}`
+      });
+    }
+    const cellOf = (name) => {
+      const at = names.indexOf(name);
+      return at === -1 ? void 0 : cells[at] ?? "";
+    };
+    const values = {};
+    for (const key of transferKeys(entry)) {
+      const field = entry.fields[key];
+      if (field && isLocalized(field, i18n)) {
+        const localized = {};
+        let present = false;
+        for (const locale of i18n.locales) {
+          const text3 = cellOf(`${key}.${locale}`);
+          if (text3 === void 0) continue;
+          present = true;
+          if (text3 !== "") localized[locale] = text3;
+        }
+        if (present) values[key] = Object.keys(localized).length ? localized : null;
+        continue;
+      }
+      const text2 = cellOf(key);
+      if (text2 === void 0) continue;
+      if (!field) {
+        values[key] = text2 === "" ? null : text2;
+        continue;
+      }
+      const result = csvCellValue(field, text2);
+      if ("error" in result) issues.push({ path: key, message: result.error });
+      else values[key] = result.value;
+    }
+    return { index, values, errors: issues };
+  });
+  return { rows, errors: [] };
+}
+export function jsonImportSource(entry, text) {
+  let data;
+  try {
+    data = JSON.parse(text.startsWith(CSV_BOM) ? text.slice(1) : text);
+  } catch (error) {
+    return { rows: [], errors: [`Invalid JSON: ${error.message}`] };
+  }
+  const items = Array.isArray(data) ? data : data && typeof data === "object" && Array.isArray(data.items) ? data.items : null;
+  if (!items)
+    return {
+      rows: [],
+      errors: ["Expected an array of entries or an object with an items array"]
+    };
+  if (items.length > IMPORT_MAX_ROWS) return { rows: [], errors: [rowTooMany(items.length)] };
+  const allowed = new Set(transferKeys(entry));
+  const rows = items.map((item, position) => {
+    const index = position + 1;
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      return { index, values: {}, errors: [{ path: "", message: "Not an object" }] };
+    }
+    const values = item;
+    const errors = Object.keys(values).filter((key) => !allowed.has(key)).map((key) => ({ path: key, message: `Unknown field '${key}'` }));
+    return { index, values: { ...values }, errors };
+  });
+  return { rows, errors: [] };
+}
+export function importSource(entry, format, text, i18n) {
+  if (format === "csv") {
+    if (!canTransferCsv(entry))
+      return { rows: [], errors: ["CSV needs an entry without blocks and many-to-many fields"] };
+    return csvImportSource(entry, text, i18n);
+  }
+  return jsonImportSource(entry, text);
+}
+export function importRowTitle(entry, values, defaultLocale) {
+  const key = entry.titleField;
+  const field = key ? entry.fields[key] : void 0;
+  const value = key ? values[key] : void 0;
+  if (!field || value === null || value === void 0 || value === "") return null;
+  if (typeof value === "object") {
+    const record = value;
+    const text = record[defaultLocale] ?? Object.values(record).find(Boolean);
+    return typeof text === "string" && text ? text : null;
+  }
+  if (field.type === "select") return selectOptionLabel(field, value);
+  return String(value);
+}
+export function importIssuePath(path) {
+  return path.map((part) => String(part)).join(".");
+}

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { CmsEntry, CmsI18n } from './index.js';
+import type { CmsEntry, CmsI18n, CmsValidationLevel, FieldConfig } from './index.js';
 export declare const objectKeySchema: z.ZodString;
 export interface ValidationMessages {
     required: string;
@@ -9,10 +9,23 @@ export interface ValidationMessages {
     invalidSlug: string;
     unknownLocale: string;
     requiredLocale: (locale: string) => string;
+    minBlocks: (min: number) => string;
+    maxBlocks: (max: number) => string;
 }
 export declare function datetimeSchema(message: string): z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-export declare function buildEntrySchema(entry: Pick<CmsEntry, 'fields'> & {
+export declare function blocksCountMessage(field: Pick<FieldConfig, 'min' | 'max'>, count: number, messages?: Partial<ValidationMessages>): string | null;
+export interface EntryValidationIssue {
+    path: (string | number)[];
+    message: string;
+    level: CmsValidationLevel;
+}
+type ValidatedEntry = Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'validate'>>;
+export declare function entryValidationIssues(entry: ValidatedEntry, values: Record<string, unknown>, i18n: CmsI18n, path?: string): EntryValidationIssue[];
+export declare function entryValidationWarnings(entry: ValidatedEntry, values: Record<string, unknown>, i18n: CmsI18n, path?: string): EntryValidationIssue[];
+export declare function buildEntrySchema(entry: ValidatedEntry & {
     drafts?: boolean;
+    path?: string;
 }, i18n: CmsI18n, messages?: Partial<ValidationMessages>): z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
 }, z.core.$strip>;
+export {};

package/dist/runtime/shared/validation.js

@@ -1,5 +1,11 @@
 import { z } from "zod";
-import { BLOCK_HIDDEN_KEY, declaresHiddenField, isFieldVisible, isTranslatableField } from "./index.js";
+import {
+  BLOCK_HIDDEN_KEY,
+  declaresHiddenField,
+  isFieldVisible,
+  isTranslatableField,
+  selectOptionValues
+} from "./index.js";
 export const objectKeySchema = z.string().min(1).max(1024).refine((k) => !k.includes("..") && !k.startsWith("/"), "Invalid object key");
 const DEFAULT_MESSAGES = {
   required: "Required field",
@@ -8,7 +14,9 @@ const DEFAULT_MESSAGES = {
   invalidEmail: "Invalid email",
   invalidSlug: "Invalid slug (lowercase letters, numbers, dashes)",
   unknownLocale: "Unknown locale key",
-  requiredLocale: (locale) => `Required field (locale '${locale}')`
+  requiredLocale: (locale) => `Required field (locale '${locale}')`,
+  minBlocks: (min) => `Add at least ${min} ${min === 1 ? "block" : "blocks"}`,
+  maxBlocks: (max) => `Add at most ${max} ${max === 1 ? "block" : "blocks"}`
 };
 const DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
 export function datetimeSchema(message) {
@@ -34,9 +42,11 @@ function scalarSchema(field, m) {
     case "slug":
       return z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, m.invalidSlug);
     case "select":
-      return z.enum(field.options);
+      return z.enum(selectOptionValues(field));
     case "media":
       return objectKeySchema;
+    case "json":
+      return z.unknown();
     default:
       return field.required ? z.string().trim().min(1, m.required) : z.string();
   }
@@ -72,6 +82,72 @@ function blocksSchema(field, i18n, m) {
   );
   return z.array(z.discriminatedUnion("type", variants));
 }
+export function blocksCountMessage(field, count, messages) {
+  const m = { ...DEFAULT_MESSAGES, ...messages };
+  if (field.max !== void 0 && count > field.max) return m.maxBlocks(field.max);
+  if (field.min !== void 0 && count > 0 && count < field.min) return m.minBlocks(field.min);
+  return null;
+}
+function boundedBlocks(list, field, m) {
+  if (field.min === void 0 && field.max === void 0) return list;
+  return list.superRefine((items, ctx) => {
+    const message = blocksCountMessage(field, items.length, m);
+    if (message) ctx.addIssue({ code: "custom", message });
+  });
+}
+function hookIssues(result) {
+  if (!Array.isArray(result)) return [];
+  return result.filter(
+    (issue) => !!issue && typeof issue === "object" && typeof issue.message === "string"
+  );
+}
+function hasValidateHooks(entry) {
+  if (entry.validate) return true;
+  return Object.values(entry.fields).some(
+    (field) => field.type === "blocks" && Object.values(field.blocks ?? {}).some((block) => block.validate)
+  );
+}
+export function entryValidationIssues(entry, values, i18n, path) {
+  const context = {
+    locales: i18n.locales,
+    defaultLocale: i18n.defaultLocale,
+    ...path ? { path } : {}
+  };
+  const issues = [];
+  if (entry.validate) {
+    for (const issue of hookIssues(entry.validate(values, context))) {
+      issues.push({
+        path: issue.field ? [issue.field] : [],
+        message: issue.message,
+        level: issue.level === "warning" ? "warning" : "error"
+      });
+    }
+  }
+  for (const [key, field] of Object.entries(entry.fields)) {
+    const list = values[key];
+    if (field.type !== "blocks" || !Array.isArray(list)) continue;
+    list.forEach((item, index) => {
+      if (!item || typeof item !== "object") return;
+      const block = field.blocks?.[String(item.type)];
+      if (!block?.validate) return;
+      const result = block.validate(item, { ...context, index });
+      for (const issue of hookIssues(result)) {
+        issues.push({
+          path: issue.field ? [key, index, issue.field] : [key, index],
+          message: issue.message,
+          level: issue.level === "warning" ? "warning" : "error"
+        });
+      }
+    });
+  }
+  return issues;
+}
+export function entryValidationWarnings(entry, values, i18n, path) {
+  if (!hasValidateHooks(entry)) return [];
+  return entryValidationIssues(entry, values, i18n, path).filter(
+    (issue) => issue.level === "warning"
+  );
+}
 function isEmptyValue(field, value, defaultLocale) {
   if (value == null) return true;
   if (Array.isArray(value)) return !value.length;
@@ -86,22 +162,27 @@ export function buildEntrySchema(entry, i18n, messages) {
   const m = { ...DEFAULT_MESSAGES, ...messages };
   const shape = {};
   const conditional = [];
+  const conditionalBounds = [];
   for (const [key, declared] of Object.entries(entry.fields)) {
     const field = declared.showIf ? { ...declared, required: false } : declared;
     if (declared.showIf && declared.required) conditional.push([key, declared]);
+    if (declared.showIf && declared.type === "blocks" && (declared.min !== void 0 || declared.max !== void 0))
+      conditionalBounds.push([key, declared]);
     if (field.type === "relation" && field.cardinality === "many-to-many") {
       const list = z.array(z.string().min(1));
       shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? []);
       continue;
     }
     if (field.type === "select" && field.multiple) {
-      const list = z.array(z.enum(field.options));
+      const list = z.array(z.enum(selectOptionValues(field)));
       shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? []);
       continue;
     }
     if (field.type === "blocks") {
       const list = blocksSchema(field, i18n, m);
-      shape[key] = field.required ? list.min(1, m.required) : list.nullish().transform((v) => v ?? null);
+      const base = field.required ? list.min(1, m.required) : list;
+      const bounded = declared.showIf ? base : boundedBlocks(base, field, m);
+      shape[key] = field.required ? bounded : bounded.nullish().transform((v) => v ?? null);
       continue;
     }
     if (isTranslatableField(field) && i18n.locales.length) {
@@ -119,13 +200,25 @@ export function buildEntrySchema(entry, i18n, messages) {
     shape.status = z.enum(["draft", "published"]).nullish().transform((v) => v ?? void 0);
   }
   const schema = z.object(shape);
-  if (!conditional.length) return schema;
-  return schema.superRefine((values, ctx) => {
+  const hooks = hasValidateHooks(entry);
+  if (!conditional.length && !conditionalBounds.length && !hooks) return schema;
+  return schema.superRefine((parsed, ctx) => {
+    const values = parsed;
     for (const [key, field] of conditional) {
       if (!isFieldVisible(field, values)) continue;
-      if (!isEmptyValue(field, values[key], i18n.defaultLocale))
-        continue;
+      if (!isEmptyValue(field, values[key], i18n.defaultLocale)) continue;
       ctx.addIssue({ code: "custom", path: [key], message: m.required });
     }
+    for (const [key, field] of conditionalBounds) {
+      const list = values[key];
+      if (!isFieldVisible(field, values) || !Array.isArray(list)) continue;
+      const message = blocksCountMessage(field, list.length, m);
+      if (message) ctx.addIssue({ code: "custom", path: [key], message });
+    }
+    if (!hooks) return;
+    for (const issue of entryValidationIssues(entry, values, i18n, entry.path)) {
+      if (issue.level === "error")
+        ctx.addIssue({ code: "custom", path: issue.path, message: issue.message });
+    }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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)",