@easy-cms/core 0.47.4 → 0.49.0

package/dist/internal.d.ts

@@ -0,0 +1,136 @@
+import { ab as Config, al as Database, bl as NavGroup, a6 as CollectionConfig, I as ID, bE as RawDocument, aD as Field, bI as ResolvedConfig, ad as ConfigIssue } from './config-jzFGsNL6.js';
+export { cH as API_KEYS, cI as API_KEY_GLOBAL_OPERATIONS, cJ as API_KEY_OPERATIONS, cK as DEFAULT_MAX_VERSIONS, cL as DEFAULT_PASSWORD_EMAILS, cM as FIELD_TYPE_BASES, cN as FOLDER_LEVELS, cO as MediaFolders, cP as SSO_COOKIE, cQ as codeOfStatus, cx as hasRows, cz as isHasMany, cR as keyAllows, cD as mimeAllowedBy, cE as rowFields, cG as uniqueWithinOf } from './config-jzFGsNL6.js';
+export { C as CONFIG_FILE_NAMES, g as CSRF_COOKIE, h as CSRF_HEADER, D as DEFAULT_ADMIN_PATH, i as DEFAULT_API_PATH, j as DEFAULT_MAX_FILE_SIZE, k as DEFAULT_TOKEN_EXPIRATION, m as applyDefaults, n as applyPlugins, o as createRootEndpointHandler, p as fillMissing, q as findConfigFile, t as forwardedClientIp, u as generateSlugs, v as importConfig, w as mergeForUpdate, x as parseId, y as platformClientIp, z as readCookie, E as validateFields, F as writeBackupFile } from './handler-CMA1LIq7.js';
+export { conditionIssues } from './conditions.js';
+
+/** The session cookie the REST API sets at login. */
+declare const SESSION_COOKIE = "ecms-session";
+
+declare const MIN_PASSWORD_LENGTH = 8;
+/** Hashes a password as `scrypt$N$r$p$salt$hash` (base64url). */
+declare function hashPassword(password: string): Promise<string>;
+/** Checks a password against a hash in constant time. Malformed hashes never match. */
+declare function verifyPassword(password: string, stored: string): Promise<boolean>;
+
+declare const MEDIA = "media";
+declare const MEDIA_FOLDERS = "media-folders";
+/** Collections Easy CMS uses internally. Not exposed over REST or in the admin UI. */
+declare const INTERNAL_COLLECTIONS: ReadonlySet<string>;
+
+/**
+ * Throws a ConfigError for options of a plugin or adapter whose name changed, so an upgrade
+ * doesn't quietly drop them. `renamed` maps the old name to the new one, maybe followed by a note.
+ */
+declare function checkRenamedOptions(where: string, options: object | undefined, renamed: Readonly<Record<string, string>>): void;
+
+/**
+ * A string that is the same for configs with the same structure: collections, fields, options
+ * and every other plain value. Functions count only by where they are, not by their code, since
+ * bundlers rename variables differently each time they compile the same source.
+ *
+ * Frameworks may load the config module more than once (Next.js bundles it into each server
+ * layer), which gives different objects for the same config; this tells those apart from edits.
+ */
+declare function configSignature(config: Config): string;
+
+interface CopyProgress {
+    readonly table: string;
+    readonly rows: number;
+}
+interface CopyResult {
+    readonly tables: number;
+    readonly rows: number;
+}
+/**
+ * Copies every stored row from `source` into `target` (another kind of database is fine, e.g.
+ * SQLite to Postgres), keeping ids, so relationships, versions and users stay as they are.
+ * Both must come from the same collections and fields, and the target must be empty.
+ * Uploaded files are not copied: they stay in the storage they are in.
+ */
+declare function copyDatabase(source: Database, target: Database, options?: {
+    onTable?: (progress: CopyProgress) => void;
+}): Promise<CopyResult>;
+
+/** File types Easy CMS recognizes from their contents (FR-UPL-03). */
+declare const EXTENSIONS: Readonly<Record<string, string>>;
+/**
+ * Names for several types at once, usable in `upload.mimeTypes` and an upload field's
+ * `mimeTypes`: `documents` (PDF, Word, Excel, PowerPoint, OpenDocument, CSV, text), `office`
+ * (docx, xlsx, pptx) and `archives` (zip).
+ */
+declare const MIME_GROUPS: Readonly<Record<string, readonly string[]>>;
+/** Patterns with group names (`documents`…) replaced by their types. */
+declare function expandMimeTypes(patterns: readonly string[]): string[];
+/**
+ * Detects the MIME type from file contents, ignoring the type the client sent. The name only
+ * tells CSV from plain text, which have the same contents.
+ */
+declare function sniffMimeType(data: Uint8Array, name?: string): string | undefined;
+/**
+ * `image/*` style matching; group names (`documents`…) stand for their types. A wildcard leaves
+ * out SVG, which can carry scripts: it is allowed only when listed as `image/svg+xml`.
+ */
+declare function mimeAllowed(type: string, allowed: readonly string[]): boolean;
+/** Width and height of PNG, GIF, JPEG and WebP images without decoding them. */
+declare function imageDimensions(data: Uint8Array, type: string): {
+    width: number;
+    height: number;
+} | undefined;
+
+/** The menu's groups that are always there. Declaring their ids changes labels, icons, order. */
+declare const BUILTIN_NAV: readonly NavGroup[];
+
+declare const DEFAULT_DEPTH = 1;
+declare const MAX_DEPTH = 3;
+/** Loads the documents of one collection that the caller may see. */
+type Loader = (collection: CollectionConfig, ids: readonly ID[]) => Promise<RawDocument[]>;
+/**
+ * Replaces relationship and upload ids with documents, `depth` levels deep.
+ * Missing (or unreadable) documents become `null` (single) or are dropped (hasMany).
+ * Returns new objects; the input is not modified.
+ */
+declare function populate(load: Loader, collections: readonly CollectionConfig[], fields: readonly Field[], docs: RawDocument[], depth: number): Promise<RawDocument[]>;
+
+/**
+ * Finds the file of an admin module (`admin.modules`): a package export or a path relative to
+ * the project root. Looks from the project root first, then from the server's entry file
+ * (a Nuxt `.output/server` build keeps traced packages next to it). `undefined` when not found.
+ */
+declare function resolveAdminModule(specifier: string, cwd?: string): string | undefined;
+
+/** A token that proves the form `purpose` names was loaded at `now`: `<time>.<signature>`. */
+declare function formToken(secret: string, purpose: string, now?: number): string;
+/**
+ * Checks a token: `ok` when the form was loaded at least `minTime` ms ago (people take a few
+ * seconds; bots don't) and less than a day ago.
+ */
+declare function checkFormToken(secret: string, purpose: string, token: unknown, minTime: number, now?: number): 'ok' | 'invalid' | 'too-fast' | 'expired';
+/**
+ * Rate-limit keys for `subject` (e.g. an IP and a form) in the current and previous window of
+ * `window` seconds. A hash with the window in it: no IP is kept, and keys from different
+ * windows can't be linked.
+ */
+declare function rateKeys(secret: string, subject: string, window: number, now?: number): {
+    current: string;
+    previous: string;
+};
+/** The hidden field bots fill in: a common name the form doesn't use. */
+declare function honeypotName(names: readonly string[]): string;
+/** Checks a Cloudflare Turnstile response with Cloudflare. */
+declare function verifyTurnstile(secretKey: string, response: unknown, ip: string | undefined, fetcher?: typeof fetch): Promise<boolean>;
+
+/** Best-effort English singular: "categories" → "category". */
+declare function singularize(word: string): string;
+/**
+ * TypeScript declarations for every collection and global, as the REST API returns them.
+ * The output has no imports, so a frontend in another repository can use it as is.
+ */
+declare function generateTypes(config: ResolvedConfig): string;
+
+declare const MIN_SECRET_LENGTH = 32;
+/** Collections that Easy CMS provides. They can be relationship targets. */
+declare const BUILTIN_COLLECTIONS: readonly ["users", "media"];
+/** Checks a config and returns every problem found. An empty array means it is valid. */
+declare function validateConfig(config: Config): ConfigIssue[];
+
+export { BUILTIN_COLLECTIONS, BUILTIN_NAV, type CopyProgress, type CopyResult, DEFAULT_DEPTH, EXTENSIONS, INTERNAL_COLLECTIONS, MAX_DEPTH, MEDIA, MEDIA_FOLDERS, MIME_GROUPS, MIN_PASSWORD_LENGTH, MIN_SECRET_LENGTH, SESSION_COOKIE, checkFormToken, checkRenamedOptions, configSignature, copyDatabase, expandMimeTypes, formToken, generateTypes, hashPassword, honeypotName, imageDimensions, mimeAllowed, populate, rateKeys, resolveAdminModule, singularize, sniffMimeType, validateConfig, verifyPassword, verifyTurnstile };

package/dist/internal.js

@@ -0,0 +1,310 @@
+import {
+  API_KEYS,
+  API_KEY_GLOBAL_OPERATIONS,
+  API_KEY_OPERATIONS,
+  BUILTIN_COLLECTIONS,
+  BUILTIN_NAV,
+  CONFIG_FILE_NAMES,
+  CSRF_COOKIE,
+  CSRF_HEADER,
+  DEFAULT_ADMIN_PATH,
+  DEFAULT_API_PATH,
+  DEFAULT_DEPTH,
+  DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_VERSIONS,
+  DEFAULT_PASSWORD_EMAILS,
+  DEFAULT_TOKEN_EXPIRATION,
+  FOLDER_LEVELS,
+  INTERNAL_COLLECTIONS,
+  MAX_DEPTH,
+  MEDIA,
+  MEDIA_FOLDERS,
+  MIN_PASSWORD_LENGTH,
+  MIN_SECRET_LENGTH,
+  MediaFolders,
+  SESSION_COOKIE,
+  SSO_COOKIE,
+  applyDefaults,
+  applyPlugins,
+  checkFormToken,
+  checkRenamedOptions,
+  configSignature,
+  copyDatabase,
+  createRootEndpointHandler,
+  fillMissing,
+  findConfigFile,
+  formToken,
+  forwardedClientIp,
+  generateSlugs,
+  hashPassword,
+  honeypotName,
+  importConfig,
+  keyAllows,
+  mergeForUpdate,
+  parseId,
+  platformClientIp,
+  populate,
+  rateKeys,
+  readCookie,
+  resolveAdminModule,
+  validateConfig,
+  validateFields,
+  verifyPassword,
+  verifyTurnstile,
+  writeBackupFile
+} from "./chunk-4PGEDNBY.js";
+import {
+  conditionIssues
+} from "./chunk-U266LV4M.js";
+import {
+  EXTENSIONS,
+  FIELD_TYPE_BASES,
+  MIME_GROUPS,
+  codeOfStatus,
+  expandMimeTypes,
+  hasRows,
+  imageDimensions,
+  isHasMany,
+  mimeAllowed,
+  mimeAllowedBy,
+  rowFields,
+  sniffMimeType,
+  uniqueWithinOf
+} from "./chunk-CGVNZUW4.js";
+
+// src/typegen.ts
+var pascal = (name) => name.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+function singularize(word) {
+  if (/ies$/i.test(word)) return word.replace(/ies$/i, "y");
+  if (/(ss|us|ia)$/i.test(word)) return word;
+  if (/(x|ch|sh)es$/i.test(word)) return word.replace(/es$/i, "");
+  return word.replace(/s$/i, "");
+}
+var quote = (value) => JSON.stringify(value);
+var key = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : quote(name);
+function names(config) {
+  const taken = /* @__PURE__ */ new Set(["ID", "RichTextDocument", "MediaSize", "Collections", "Globals"]);
+  const claim = (base, suffix) => {
+    let name = base || suffix;
+    if (taken.has(name)) name = `${base}${suffix}`;
+    for (let n = 2; taken.has(name); n++) name = `${base}${suffix}${n}`;
+    taken.add(name);
+    return name;
+  };
+  const collections = /* @__PURE__ */ new Map();
+  for (const c of config.collections) {
+    if (!INTERNAL_COLLECTIONS.has(c.slug))
+      collections.set(c.slug, claim(pascal(singularize(c.slug)), "Document"));
+  }
+  const globals = /* @__PURE__ */ new Map();
+  for (const g of config.globals) globals.set(g.slug, claim(pascal(g.slug), "Global"));
+  const custom = new Map(
+    (config.fieldTypes ?? []).filter((t) => t.typescript).map((t) => [t.name, t.typescript])
+  );
+  return { collections, globals, custom };
+}
+function fieldType(field, n, indent) {
+  const custom = field.customType ? n.custom.get(field.customType) : void 0;
+  if (custom) return custom;
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "email":
+    case "slug":
+    case "date":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+      return "unknown";
+    case "richText":
+      return "RichTextDocument";
+    case "select": {
+      const union = field.options.map((o) => quote(typeof o === "string" ? o : o.value)).join(" | ") || "string";
+      return field.hasMany ? `(${union})[]` : union;
+    }
+    case "upload": {
+      const one = `ID | ${n.collections.get(MEDIA) ?? "Record<string, unknown>"}`;
+      return field.hasMany ? `(${one})[]` : one;
+    }
+    case "relationship": {
+      const target = n.collections.get(field.to);
+      const one = target ? `ID | ${target}` : "ID";
+      return field.hasMany ? `(${one})[]` : one;
+    }
+    case "group":
+      return `{
+${fieldLines(field.fields, n, `${indent}  `).join("\n")}
+${indent}}`;
+    case "array":
+      return `{
+${indent}  id: string
+${fieldLines(field.fields, n, `${indent}  `).join("\n")}
+${indent}}[]`;
+    case "blocks": {
+      const kinds = field.blocks.map(
+        (block) => `{
+${indent}  id: string
+${indent}  blockType: ${quote(block.slug)}
+${fieldLines(block.fields, n, `${indent}  `).join("\n")}
+${indent}}`
+      );
+      return `(${kinds.join(" | ")})[]`;
+    }
+  }
+}
+function fieldLines(fields, n, indent) {
+  const lines = [];
+  for (const field of fields) {
+    if (field.hidden) continue;
+    const type = fieldType(field, n, indent);
+    const alwaysPresent = field.type === "array" || field.type === "blocks" || field.type === "group" || isHasMany(field);
+    if (field.required || alwaysPresent) lines.push(`${indent}${key(field.name)}: ${type}`);
+    else lines.push(`${indent}${key(field.name)}?: ${type} | null`);
+  }
+  return lines;
+}
+function collectionInterface(collection, name, n) {
+  const lines = ["  id: ID"];
+  if (collection.slug === MEDIA) {
+    lines.push("  url: string", "  sizes: Record<string, MediaSize>");
+  }
+  const fields = collection.slug === MEDIA ? collection.fields.filter((f) => f.name !== "sizes") : collection.fields;
+  lines.push(...fieldLines(fields, n, "  "));
+  if (collection.drafts) lines.push(`  status: 'draft' | 'published'`);
+  lines.push("  createdAt: string", "  updatedAt: string");
+  return `export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function globalInterface(global, name, n) {
+  const lines = [...fieldLines(global.fields, n, "  ")];
+  if (global.drafts) lines.push(`  status: 'draft' | 'published'`);
+  lines.push(
+    "  /** `null` until the global is saved for the first time. */",
+    "  updatedAt: string | null"
+  );
+  return `export interface ${name} {
+${lines.join("\n")}
+}`;
+}
+function generateTypes(config) {
+  const n = names(config);
+  const parts = [
+    "// Generated by `easy-cms generate:types`. Do not edit; run the command again after changing the config.",
+    "",
+    "/** Document ids are integers. */",
+    "export type ID = number",
+    "",
+    "/** Rich text as stored: a Tiptap / ProseMirror JSON document. */",
+    "export interface RichTextDocument {",
+    `  type: 'doc'`,
+    "  content?: unknown[]",
+    "}",
+    "",
+    "export interface MediaSize {",
+    "  filename: string",
+    "  width: number",
+    "  height: number",
+    "  filesize: number",
+    "  url: string",
+    "}"
+  ];
+  for (const collection of config.collections) {
+    const name = n.collections.get(collection.slug);
+    if (name) parts.push("", collectionInterface(collection, name, n));
+  }
+  for (const global of config.globals) {
+    parts.push("", globalInterface(global, n.globals.get(global.slug), n));
+  }
+  const map = (entries) => [...entries].map(([slug, name]) => `  ${key(slug)}: ${name}`).join("\n");
+  parts.push(
+    "",
+    "/** Document type by collection slug. */",
+    `export interface Collections {
+${map(n.collections)}
+}`
+  );
+  parts.push(
+    "",
+    "/** Data type by global slug. */",
+    `export interface Globals {
+${map(n.globals)}
+}`,
+    ""
+  );
+  return parts.join("\n");
+}
+export {
+  API_KEYS,
+  API_KEY_GLOBAL_OPERATIONS,
+  API_KEY_OPERATIONS,
+  BUILTIN_COLLECTIONS,
+  BUILTIN_NAV,
+  CONFIG_FILE_NAMES,
+  CSRF_COOKIE,
+  CSRF_HEADER,
+  DEFAULT_ADMIN_PATH,
+  DEFAULT_API_PATH,
+  DEFAULT_DEPTH,
+  DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_VERSIONS,
+  DEFAULT_PASSWORD_EMAILS,
+  DEFAULT_TOKEN_EXPIRATION,
+  EXTENSIONS,
+  FIELD_TYPE_BASES,
+  FOLDER_LEVELS,
+  INTERNAL_COLLECTIONS,
+  MAX_DEPTH,
+  MEDIA,
+  MEDIA_FOLDERS,
+  MIME_GROUPS,
+  MIN_PASSWORD_LENGTH,
+  MIN_SECRET_LENGTH,
+  MediaFolders,
+  SESSION_COOKIE,
+  SSO_COOKIE,
+  applyDefaults,
+  applyPlugins,
+  checkFormToken,
+  checkRenamedOptions,
+  codeOfStatus,
+  conditionIssues,
+  configSignature,
+  copyDatabase,
+  createRootEndpointHandler,
+  expandMimeTypes,
+  fillMissing,
+  findConfigFile,
+  formToken,
+  forwardedClientIp,
+  generateSlugs,
+  generateTypes,
+  hasRows,
+  hashPassword,
+  honeypotName,
+  imageDimensions,
+  importConfig,
+  isHasMany,
+  keyAllows,
+  mergeForUpdate,
+  mimeAllowed,
+  mimeAllowedBy,
+  parseId,
+  platformClientIp,
+  populate,
+  rateKeys,
+  readCookie,
+  resolveAdminModule,
+  rowFields,
+  singularize,
+  sniffMimeType,
+  uniqueWithinOf,
+  validateConfig,
+  validateFields,
+  verifyPassword,
+  verifyTurnstile,
+  writeBackupFile
+};