@vicacha-devs/strapi-plugin-notes 0.0.0-stage → 1.1.0

package/dist/shared/index.js

@@ -0,0 +1,525 @@
+const PLUGIN_ID = "notes";
+const NOTE_CONTENT_TYPE_UID = "plugin::notes.note";
+const NOTE_CATEGORIES = ["general", "todo", "blocker", "idea"];
+const MAX_NOTE_TITLE_LENGTH = 255;
+const MAX_NOTE_CONTENT_LENGTH = 2e4;
+const MAX_ENTITY_SLUG_LENGTH = 160;
+const MAX_ENTITY_ID_LENGTH = 128;
+const MAX_LOCALE_LENGTH = 32;
+const NOTE_CATEGORY_META = {
+  general: {
+    labelKey: "category.general",
+    defaultLabel: "General",
+    badgeBackground: "neutral150",
+    badgeTextColor: "neutral800"
+  },
+  todo: {
+    labelKey: "category.todo",
+    defaultLabel: "Todo",
+    badgeBackground: "primary100",
+    badgeTextColor: "primary700"
+  },
+  blocker: {
+    labelKey: "category.blocker",
+    defaultLabel: "Blocker",
+    badgeBackground: "danger100",
+    badgeTextColor: "danger700"
+  },
+  idea: {
+    labelKey: "category.idea",
+    defaultLabel: "Idea",
+    badgeBackground: "success100",
+    badgeTextColor: "success700"
+  }
+};
+const ENTITY_SLUG_PATTERN = /^[a-zA-Z0-9_:.-]{1,160}$/;
+const SAFE_ID_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+const LOCALE_PATTERN = /^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8}){0,4}$/;
+const FORBIDDEN_IDENTIFIER_TOKENS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isForbiddenIdentifier(value) {
+  const lower = value.toLowerCase();
+  if (FORBIDDEN_IDENTIFIER_TOKENS.has(lower)) return true;
+  if (value === "." || value === ".." || value.includes("..") || value.startsWith(".") || value.endsWith(".")) {
+    return true;
+  }
+  return lower.split(/[:./]+/).some((segment) => FORBIDDEN_IDENTIFIER_TOKENS.has(segment));
+}
+function toPositiveSafeInt(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) return null;
+  const truncated = Math.trunc(input);
+  return Number.isSafeInteger(truncated) && truncated >= 1 ? truncated : null;
+}
+function isValidNoteCategory(value) {
+  return typeof value === "string" && NOTE_CATEGORIES.includes(value);
+}
+function normalizeNoteCategory(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (isValidNoteCategory(normalized)) return normalized;
+  }
+  return "general";
+}
+function sanitizePlainText(input, maxLength) {
+  if (typeof input !== "string") return "";
+  const cleaned = input.replace(/\0/g, "").replace(/\r\n/g, "\n").trim();
+  return cleaned.length > maxLength ? cleaned.slice(0, maxLength) : cleaned;
+}
+function sanitizeEntitySlug(input) {
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_SLUG_LENGTH || isForbiddenIdentifier(cleaned) || !ENTITY_SLUG_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function sanitizeEntityDocumentId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) return String(numeric);
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(cleaned) || !SAFE_ID_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function parseStringEntityId(input) {
+  if (input.includes("\0")) return null;
+  const trimmed = input.trim();
+  if (!trimmed || trimmed.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(trimmed)) {
+    return null;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  return SAFE_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function sanitizeEntityId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof input === "string") {
+    return parseStringEntityId(input);
+  }
+  return null;
+}
+function isWildcardOrInvalidLocale(cleaned) {
+  if (!cleaned || cleaned === "all" || cleaned === "*") {
+    return true;
+  }
+  return cleaned.length > MAX_LOCALE_LENGTH || isForbiddenIdentifier(cleaned);
+}
+function sanitizeEntityLocale(input) {
+  if (typeof input !== "string" || input.includes("\0")) {
+    return null;
+  }
+  const cleaned = input.trim();
+  if (isWildcardOrInvalidLocale(cleaned)) {
+    return null;
+  }
+  return LOCALE_PATTERN.test(cleaned) ? cleaned : null;
+}
+function extractPrimitiveAuthorId(rawUser) {
+  const numeric = toPositiveSafeInt(rawUser);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof rawUser === "string" && rawUser.trim()) {
+    return sanitizeEntityDocumentId(rawUser) || null;
+  }
+  return null;
+}
+function sanitizePrimitiveAuthor(rawUser, fallback) {
+  const primitiveId = extractPrimitiveAuthorId(rawUser);
+  if (!fallback && primitiveId === null) {
+    return null;
+  }
+  return {
+    id: primitiveId,
+    firstname: "",
+    lastname: "",
+    username: "",
+    displayName: fallback || `#${String(primitiveId)}`
+  };
+}
+function asPlainObject(value, fallback) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : fallback;
+}
+function unwrapAuthorRecord(rawUser) {
+  const nestedData = asPlainObject(rawUser.data, rawUser);
+  const attrs = asPlainObject(nestedData.attributes, nestedData);
+  const id = extractPrimitiveAuthorId(nestedData.id ?? rawUser.id);
+  return { attrs, id };
+}
+function sanitizeNoteAuthor(rawUser, fallbackDisplayName) {
+  const fallback = sanitizePlainText(fallbackDisplayName, 120);
+  if (!rawUser || typeof rawUser !== "object" || Array.isArray(rawUser)) {
+    return sanitizePrimitiveAuthor(rawUser, fallback);
+  }
+  const { attrs, id } = unwrapAuthorRecord(rawUser);
+  const firstname = sanitizePlainText(attrs.firstname, 80);
+  const lastname = sanitizePlainText(attrs.lastname, 80);
+  const username = sanitizePlainText(attrs.username, 80);
+  const explicitDisplayName = sanitizePlainText(attrs.displayName, 120);
+  const fullName = [firstname, lastname].filter(Boolean).join(" ").trim();
+  const displayName = fullName || username || explicitDisplayName || fallback || "";
+  if (!displayName && id === null) {
+    return null;
+  }
+  return {
+    id,
+    firstname,
+    lastname,
+    username,
+    displayName: displayName || `#${String(id)}`
+  };
+}
+function formatNoteAuthorDisplay(author, emptyFallback = "-") {
+  if (!author) {
+    return emptyFallback;
+  }
+  const fullName = [author.firstname, author.lastname].filter(Boolean).join(" ").trim();
+  if (fullName) {
+    return fullName;
+  }
+  if (author.username && author.username.trim()) {
+    return author.username.trim();
+  }
+  if (author.displayName && author.displayName.trim()) {
+    return author.displayName.trim();
+  }
+  return emptyFallback;
+}
+function formatNoteTimestamp(isoString, locale = "en", emptyFallback = "-") {
+  if (!isoString || typeof isoString !== "string") {
+    return emptyFallback;
+  }
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    return emptyFallback;
+  }
+  try {
+    return new Intl.DateTimeFormat(locale || "en", {
+      dateStyle: "medium",
+      timeStyle: "short"
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function extractRecordId(root, attrs) {
+  if (typeof root.id === "number" && Number.isFinite(root.id) || typeof root.id === "string") {
+    return root.id;
+  }
+  if (typeof attrs.id === "number" && Number.isFinite(attrs.id) || typeof attrs.id === "string") {
+    return attrs.id;
+  }
+  return "";
+}
+function sanitizeOptionalIsoString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function unwrapRawNoteAttributes(raw) {
+  const root = asPlainObject(raw, {});
+  const rawAttrs = asPlainObject(root.attributes, {});
+  const attrs = { ...root, ...rawAttrs };
+  return { root, attrs };
+}
+function normalizeNoteRecord(raw) {
+  const { root, attrs } = unwrapRawNoteAttributes(raw);
+  const id = extractRecordId(root, attrs);
+  const documentId = sanitizeEntityDocumentId(root.documentId ?? attrs.documentId) || String(id || "");
+  const entityId = sanitizeEntityId(attrs.entityId);
+  const entityDocumentId = sanitizeEntityDocumentId(attrs.entityDocumentId) || (entityId !== null ? String(entityId) : "");
+  const createdBy = sanitizeNoteAuthor(
+    attrs.createdBy,
+    attrs.createdByName ?? attrs.authorName
+  );
+  const updatedBy = sanitizeNoteAuthor(attrs.updatedBy, attrs.updatedByName) ?? createdBy;
+  const createdAt = sanitizeOptionalIsoString(attrs.createdAt);
+  const updatedAt = sanitizeOptionalIsoString(attrs.updatedAt) ?? createdAt;
+  const normalizedAttributes = {
+    title: sanitizePlainText(attrs.title, MAX_NOTE_TITLE_LENGTH),
+    content: sanitizePlainText(attrs.content, MAX_NOTE_CONTENT_LENGTH),
+    category: normalizeNoteCategory(attrs.category),
+    isPinned: Boolean(attrs.isPinned),
+    entitySlug: sanitizeEntitySlug(attrs.entitySlug),
+    entityId,
+    entityDocumentId,
+    entityLocale: sanitizeEntityLocale(attrs.entityLocale),
+    createdAt,
+    updatedAt,
+    createdBy,
+    updatedBy
+  };
+  return {
+    id,
+    documentId,
+    ...normalizedAttributes,
+    attributes: normalizedAttributes
+  };
+}
+function validateNoteCreatePayload(input) {
+  const raw = unwrapDataEnvelope(input);
+  const errors = [];
+  const title = sanitizePlainText(raw.title, MAX_NOTE_TITLE_LENGTH);
+  const content = sanitizePlainText(raw.content, MAX_NOTE_CONTENT_LENGTH);
+  const category = normalizeNoteCategory(raw.category);
+  const isPinned = Boolean(raw.isPinned);
+  const entitySlug = sanitizeEntitySlug(raw.entitySlug);
+  const entityId = sanitizeEntityId(raw.entityId);
+  const entityDocumentId = sanitizeEntityDocumentId(raw.entityDocumentId) || (entityId !== null ? String(entityId) : "");
+  const entityLocale = sanitizeEntityLocale(raw.entityLocale);
+  if (!title) {
+    errors.push("Note title is required.");
+  }
+  if (!entitySlug) {
+    errors.push("A valid target entitySlug is required.");
+  }
+  if (!entityDocumentId && entityId === null) {
+    errors.push("Either entityDocumentId or entityId is required.");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    data: {
+      title,
+      content,
+      category,
+      isPinned,
+      entitySlug,
+      entityId,
+      entityDocumentId,
+      entityLocale
+    }
+  };
+}
+function applyEntityTargetUpdates(raw, hasOwn, data, errors) {
+  if (hasOwn("entityDocumentId")) {
+    const docId = sanitizeEntityDocumentId(raw.entityDocumentId);
+    if (docId) data.entityDocumentId = docId;
+  }
+  if (hasOwn("entityId")) {
+    const entityId = sanitizeEntityId(raw.entityId);
+    if (entityId !== null) data.entityId = entityId;
+  }
+  if (hasOwn("entitySlug")) {
+    const slug = sanitizeEntitySlug(raw.entitySlug);
+    if (slug) {
+      data.entitySlug = slug;
+    } else if (raw.entitySlug !== void 0 && raw.entitySlug !== null) {
+      errors.push("A valid target entitySlug is required.");
+    }
+  }
+}
+function validateNoteUpdatePayload(input) {
+  const raw = unwrapDataEnvelope(input);
+  const errors = [];
+  const data = {};
+  const hasOwn = (key) => Object.prototype.hasOwnProperty.call(raw, key);
+  if (hasOwn("title")) {
+    const title = sanitizePlainText(raw.title, MAX_NOTE_TITLE_LENGTH);
+    if (!title) {
+      errors.push("Note title cannot be empty.");
+    } else {
+      data.title = title;
+    }
+  }
+  if (hasOwn("content")) {
+    data.content = sanitizePlainText(raw.content, MAX_NOTE_CONTENT_LENGTH);
+  }
+  if (hasOwn("category")) {
+    data.category = normalizeNoteCategory(raw.category);
+  }
+  if (hasOwn("isPinned")) {
+    data.isPinned = Boolean(raw.isPinned);
+  }
+  if (hasOwn("entityLocale")) {
+    data.entityLocale = sanitizeEntityLocale(raw.entityLocale);
+  }
+  applyEntityTargetUpdates(raw, hasOwn, data, errors);
+  if (Object.keys(data).length === 0 && errors.length === 0) {
+    errors.push("At least one valid note field must be provided for update.");
+  }
+  return { valid: errors.length === 0, errors, data };
+}
+function unwrapDataEnvelope(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return {};
+  }
+  const obj = input;
+  if (obj.data && typeof obj.data === "object" && !Array.isArray(obj.data)) {
+    return obj.data;
+  }
+  if (obj.body && typeof obj.body === "object" && !Array.isArray(obj.body)) {
+    return obj.body;
+  }
+  return obj;
+}
+function sortNotesPinnedFirst(notes, direction = "DESC") {
+  return [...notes].sort((a, b) => {
+    if (a.isPinned !== b.isPinned) {
+      return a.isPinned ? -1 : 1;
+    }
+    const timeA = a.createdAt ? Date.parse(a.createdAt) : 0;
+    const timeB = b.createdAt ? Date.parse(b.createdAt) : 0;
+    if (timeA !== timeB && !Number.isNaN(timeA) && !Number.isNaN(timeB)) {
+      return direction === "ASC" ? timeA - timeB : timeB - timeA;
+    }
+    return String(a.id).localeCompare(String(b.id));
+  });
+}
+function matchesEntityIdentifier(note, docIdFilter, entityIdFilter) {
+  if (!docIdFilter && entityIdFilter === null) {
+    return true;
+  }
+  const noteIdStr = note.entityId !== null ? String(note.entityId) : "";
+  if (docIdFilter) {
+    if (note.entityDocumentId === docIdFilter || noteIdStr === docIdFilter) {
+      return true;
+    }
+  }
+  if (entityIdFilter !== null) {
+    const filterStr = String(entityIdFilter);
+    if (noteIdStr === filterStr || note.entityDocumentId === filterStr) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesLocaleFilter(note, localeFilter, includeAllLocales) {
+  if (!localeFilter || includeAllLocales) {
+    return true;
+  }
+  return !note.entityLocale || note.entityLocale === localeFilter;
+}
+function matchesSearchFilter(note, searchFilter) {
+  if (!searchFilter) {
+    return true;
+  }
+  const haystack = [
+    note.title,
+    note.content,
+    note.entitySlug,
+    note.createdBy?.displayName ?? "",
+    note.updatedBy?.displayName ?? ""
+  ].join(" ").toLowerCase();
+  return haystack.includes(searchFilter);
+}
+function matchesAllNoteFilters(note, filters) {
+  if (filters.slugFilter && note.entitySlug !== filters.slugFilter) {
+    return false;
+  }
+  if (!matchesEntityIdentifier(note, filters.docIdFilter, filters.entityIdFilter)) {
+    return false;
+  }
+  if (!matchesLocaleFilter(note, filters.localeFilter, filters.includeAllLocales)) {
+    return false;
+  }
+  if (filters.categoryFilter && note.category !== filters.categoryFilter) {
+    return false;
+  }
+  if (typeof filters.isPinned === "boolean" && note.isPinned !== filters.isPinned) {
+    return false;
+  }
+  return matchesSearchFilter(note, filters.searchFilter);
+}
+function filterNotesList(notes, params = {}) {
+  const filters = {
+    slugFilter: params.entitySlug ? sanitizeEntitySlug(params.entitySlug) : "",
+    docIdFilter: params.entityDocumentId ? sanitizeEntityDocumentId(params.entityDocumentId) : "",
+    entityIdFilter: params.entityId !== void 0 && params.entityId !== null ? sanitizeEntityId(params.entityId) : null,
+    localeFilter: sanitizeEntityLocale(params.entityLocale),
+    includeAllLocales: params.includeAllLocales,
+    categoryFilter: params.category && params.category !== "all" ? normalizeNoteCategory(params.category) : null,
+    isPinned: params.isPinned,
+    searchFilter: sanitizePlainText(params.search, 160).toLowerCase()
+  };
+  const filtered = notes.filter((note) => matchesAllNoteFilters(note, filters));
+  const sorted = sortNotesPinnedFirst(filtered, params.sort ?? "DESC");
+  const offset = typeof params.offset === "number" && Number.isFinite(params.offset) && params.offset > 0 ? Math.trunc(params.offset) : 0;
+  const limit = typeof params.limit === "number" && Number.isFinite(params.limit) && params.limit > 0 ? Math.trunc(params.limit) : void 0;
+  if (offset > 0 || limit !== void 0) {
+    return sorted.slice(
+      offset,
+      limit !== void 0 ? offset + limit : void 0
+    );
+  }
+  return sorted;
+}
+function computeNotesSummaryStats(notes) {
+  const byCategory = {
+    general: 0,
+    todo: 0,
+    blocker: 0,
+    idea: 0
+  };
+  let pinned = 0;
+  const slugSet = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    if (note.isPinned) {
+      pinned += 1;
+    }
+    const cat = normalizeNoteCategory(note.category);
+    byCategory[cat] += 1;
+    if (note.entitySlug) {
+      slugSet.add(note.entitySlug);
+    }
+  }
+  return {
+    total: notes.length,
+    pinned,
+    byCategory,
+    entitySlugs: Array.from(slugSet).sort()
+  };
+}
+function buildContentManagerNoteLink(note) {
+  const slug = sanitizeEntitySlug(note.entitySlug);
+  const targetId = sanitizeEntityDocumentId(note.entityDocumentId) || (note.entityId !== null && note.entityId !== void 0 ? sanitizeEntityDocumentId(String(note.entityId)) : "");
+  const isSingleType = note.collectionType === "single-types" || note.collectionType === "singleType" || targetId === "single";
+  if (!slug || !isSingleType && !targetId) {
+    return null;
+  }
+  const basePath = isSingleType ? `/content-manager/single-types/${encodeURIComponent(slug)}` : `/content-manager/collection-types/${encodeURIComponent(
+    slug
+  )}/${encodeURIComponent(targetId)}`;
+  const locale = sanitizeEntityLocale(note.entityLocale);
+  if (locale) {
+    return `${basePath}?plugins[i18n][locale]=${encodeURIComponent(locale)}`;
+  }
+  return basePath;
+}
+export {
+  MAX_ENTITY_ID_LENGTH,
+  MAX_ENTITY_SLUG_LENGTH,
+  MAX_LOCALE_LENGTH,
+  MAX_NOTE_CONTENT_LENGTH,
+  MAX_NOTE_TITLE_LENGTH,
+  NOTE_CATEGORIES,
+  NOTE_CATEGORY_META,
+  NOTE_CONTENT_TYPE_UID,
+  PLUGIN_ID,
+  buildContentManagerNoteLink,
+  computeNotesSummaryStats,
+  filterNotesList,
+  formatNoteAuthorDisplay,
+  formatNoteTimestamp,
+  isValidNoteCategory,
+  normalizeNoteCategory,
+  normalizeNoteRecord,
+  sanitizeEntityDocumentId,
+  sanitizeEntityId,
+  sanitizeEntityLocale,
+  sanitizeEntitySlug,
+  sanitizeNoteAuthor,
+  sanitizePlainText,
+  sortNotesPinnedFirst,
+  unwrapDataEnvelope,
+  validateNoteCreatePayload,
+  validateNoteUpdatePayload
+};