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

package/dist/server/index.js

@@ -0,0 +1,1212 @@
+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 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 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()
+  };
+}
+const bootstrap = async ({ strapi }) => {
+  const actionProvider = strapi.admin?.services?.permission?.actionProvider;
+  if (actionProvider && typeof actionProvider.registerMany === "function") {
+    await actionProvider.registerMany([
+      {
+        section: "plugins",
+        displayName: "Read notes",
+        uid: "read",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Create & edit notes",
+        uid: "update",
+        pluginName: PLUGIN_ID
+      },
+      {
+        section: "plugins",
+        displayName: "Delete notes",
+        uid: "delete",
+        pluginName: PLUGIN_ID
+      }
+    ]);
+  }
+};
+const config = {
+  default: {
+    defaultSortOrder: "DESC",
+    enableLocaleScoping: true
+  },
+  validator(config2) {
+    if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) {
+      throw new Error("Invalid notes plugin config: expected an object.");
+    }
+    if (config2.defaultSortOrder !== void 0 && config2.defaultSortOrder !== "ASC" && config2.defaultSortOrder !== "DESC") {
+      throw new Error(
+        'Invalid notes plugin config: defaultSortOrder must be "ASC" or "DESC".'
+      );
+    }
+    if (config2.enableLocaleScoping !== void 0 && typeof config2.enableLocaleScoping !== "boolean") {
+      throw new Error(
+        "Invalid notes plugin config: enableLocaleScoping must be a boolean."
+      );
+    }
+  }
+};
+const kind = "collectionType";
+const collectionName = "notes";
+const info = { "singularName": "note", "pluralName": "notes", "displayName": "Notes", "description": "Editorial notes attached to Content Manager entity records" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes = { "title": { "type": "string", "required": true, "maxLength": 255 }, "content": { "type": "text" }, "category": { "type": "enumeration", "enum": ["general", "todo", "blocker", "idea"], "default": "general", "required": true }, "isPinned": { "type": "boolean", "default": false }, "entityId": { "type": "integer" }, "entityDocumentId": { "type": "string", "maxLength": 128 }, "entitySlug": { "type": "string", "required": true, "maxLength": 160 }, "entityLocale": { "type": "string", "maxLength": 32 }, "createdByName": { "type": "string", "maxLength": 120 }, "updatedByName": { "type": "string", "maxLength": 120 } };
+const noteSchema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  note: {
+    schema: noteSchema
+  }
+};
+function asObjectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function getNotesPluginConfig(strapi) {
+  const raw = typeof strapi?.config?.get === "function" ? strapi.config.get(`plugin::${PLUGIN_ID}`, {}) : {};
+  const configObj = asObjectRecord(raw);
+  const defaultSortOrder = configObj.defaultSortOrder === "ASC" ? "ASC" : "DESC";
+  const enableLocaleScoping = typeof configObj.enableLocaleScoping === "boolean" ? configObj.enableLocaleScoping : true;
+  return { defaultSortOrder, enableLocaleScoping };
+}
+function extractFilterValue(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    if ("$eq" in obj) {
+      return obj.$eq;
+    }
+  }
+  return value;
+}
+function pickQueryField(rawQuery, filtersObj, key) {
+  return rawQuery[key] ?? extractFilterValue(filtersObj[key]) ?? rawQuery[`filters[${key}]`] ?? rawQuery[`filters[${key}][$eq]`];
+}
+function resolveSortDirection(rawQuery, sortObj, defaultSortOrder = "DESC") {
+  const candidates = [
+    rawQuery.sort,
+    sortObj.createdAt,
+    rawQuery["sort[createdAt]"]
+  ];
+  const rawSort = candidates.find((val) => typeof val === "string");
+  if (typeof rawSort !== "string" || !rawSort.trim()) {
+    return defaultSortOrder;
+  }
+  return rawSort.toUpperCase().includes("ASC") ? "ASC" : "DESC";
+}
+function parseOptionalBoolean(value) {
+  if (value === true || value === "true") return true;
+  if (value === false || value === "false") return false;
+  return void 0;
+}
+function parseOptionalNonNegativeInt(value, minValue) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const truncated = Math.trunc(value);
+    return truncated >= minValue ? truncated : void 0;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    const parsed = Number.parseInt(value.trim(), 10);
+    return Number.isSafeInteger(parsed) && parsed >= minValue ? parsed : void 0;
+  }
+  return void 0;
+}
+function parseCategoryFilter(rawCategory) {
+  if (rawCategory === "all" || !rawCategory) {
+    return "all";
+  }
+  return normalizeNoteCategory(rawCategory);
+}
+function parseNoteQueryFilters(rawQuery = {}, pluginConfig) {
+  const filtersObj = asObjectRecord(rawQuery.filters);
+  const sortObj = asObjectRecord(rawQuery.sort);
+  const paginationObj = asObjectRecord(rawQuery.pagination);
+  const localeScopingEnabled = pluginConfig?.enableLocaleScoping !== false;
+  const defaultSortOrder = pluginConfig?.defaultSortOrder === "ASC" ? "ASC" : "DESC";
+  const rawSlug = pickQueryField(rawQuery, filtersObj, "entitySlug");
+  const rawDocId = pickQueryField(rawQuery, filtersObj, "entityDocumentId");
+  const rawEntityId = pickQueryField(rawQuery, filtersObj, "entityId");
+  const rawLocale = pickQueryField(rawQuery, filtersObj, "entityLocale");
+  const rawCategory = rawQuery.category ?? extractFilterValue(filtersObj.category);
+  const rawPinned = rawQuery.isPinned ?? extractFilterValue(filtersObj.isPinned);
+  const includeAllLocales = !localeScopingEnabled || parseOptionalBoolean(rawQuery.includeAllLocales) === true;
+  return {
+    entitySlug: sanitizeEntitySlug(rawSlug) || void 0,
+    entityDocumentId: sanitizeEntityDocumentId(rawDocId) || void 0,
+    entityId: sanitizeEntityId(rawEntityId),
+    entityLocale: localeScopingEnabled ? sanitizeEntityLocale(rawLocale) : null,
+    includeAllLocales,
+    category: parseCategoryFilter(rawCategory),
+    isPinned: parseOptionalBoolean(rawPinned),
+    search: sanitizePlainText(rawQuery.search ?? rawQuery._q, 160) || void 0,
+    sort: resolveSortDirection(rawQuery, sortObj, defaultSortOrder),
+    limit: parseOptionalNonNegativeInt(
+      rawQuery.limit ?? paginationObj.limit ?? paginationObj.pageSize,
+      1
+    ),
+    offset: parseOptionalNonNegativeInt(
+      rawQuery.offset ?? paginationObj.offset ?? paginationObj.start,
+      0
+    )
+  };
+}
+function buildDbWhereClause(filters = {}) {
+  const where = {};
+  if (filters.entitySlug) {
+    where.entitySlug = filters.entitySlug;
+  }
+  if (filters.category && filters.category !== "all") {
+    where.category = filters.category;
+  }
+  if (typeof filters.isPinned === "boolean") {
+    where.isPinned = filters.isPinned;
+  }
+  return where;
+}
+function hasAuthorIdentityFields(record) {
+  const keys = ["firstname", "lastname", "username", "displayName"];
+  return keys.some(
+    (key) => typeof record[key] === "string" && record[key].trim().length > 0
+  );
+}
+function hasPopulatedAuthorIdentity(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const root = value;
+  if (hasAuthorIdentityFields(root)) {
+    return true;
+  }
+  const nestedData = asObjectRecord(root.data);
+  if (hasAuthorIdentityFields(nestedData)) {
+    return true;
+  }
+  const nestedAttrs = asObjectRecord(nestedData.attributes ?? root.attributes);
+  return hasAuthorIdentityFields(nestedAttrs);
+}
+function resolvePopulatedAuthor(dbValue, fallbackAuthor) {
+  if (hasPopulatedAuthorIdentity(dbValue)) {
+    return dbValue;
+  }
+  return fallbackAuthor ?? dbValue;
+}
+class NotesValidationError extends Error {
+  status = 400;
+  details;
+  constructor(errors) {
+    super(errors.join(" "));
+    this.name = "NotesValidationError";
+    this.details = errors;
+  }
+}
+function getDbQuery(strapi) {
+  if (typeof strapi?.db?.query === "function") {
+    return strapi.db.query(NOTE_CONTENT_TYPE_UID);
+  }
+  if (typeof strapi?.query === "function") {
+    return strapi.query(NOTE_CONTENT_TYPE_UID);
+  }
+  return null;
+}
+function getDocService(strapi) {
+  if (typeof strapi?.documents === "function") {
+    return strapi.documents(NOTE_CONTENT_TYPE_UID) ?? null;
+  }
+  return null;
+}
+function hasExternalStorage(strapi) {
+  return Boolean(getDbQuery(strapi) || getDocService(strapi));
+}
+function hasNamedActorDisplay(actor) {
+  if (!actor) return false;
+  return Boolean(
+    actor.firstname || actor.lastname || actor.username || actor.displayName && !actor.displayName.startsWith("#")
+  );
+}
+function mergeUpdatedNoteRecord(existing, updated, actor) {
+  return normalizeNoteRecord({
+    ...existing,
+    ...updated,
+    createdBy: resolvePopulatedAuthor(updated.createdBy, existing.createdBy),
+    updatedBy: resolvePopulatedAuthor(
+      updated.updatedBy,
+      actor ?? existing.updatedBy
+    )
+  });
+}
+const MAX_SQL_INT32 = 2147483647;
+function toSqlInt32(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_SQL_INT32) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d{1,10}$/.test(value)) {
+    const parsed = Number.parseInt(value, 10);
+    if (parsed >= 1 && parsed <= MAX_SQL_INT32) {
+      return parsed;
+    }
+  }
+  return null;
+}
+async function queryDbByIdentifier(strapi, cleanStr) {
+  const dbQuery = getDbQuery(strapi);
+  if (!dbQuery || typeof dbQuery.findOne !== "function") {
+    return null;
+  }
+  const numericId = toSqlInt32(cleanStr);
+  if (numericId !== null) {
+    const byId = await dbQuery.findOne({
+      where: { id: numericId },
+      populate: ["createdBy", "updatedBy"]
+    });
+    if (byId) return byId;
+  }
+  const byDocId = await dbQuery.findOne({
+    where: { documentId: cleanStr },
+    populate: ["createdBy", "updatedBy"]
+  });
+  return byDocId ?? null;
+}
+async function queryDocServiceByIdentifier(strapi, cleanStr) {
+  const docService = getDocService(strapi);
+  if (!docService || typeof docService.findOne !== "function") {
+    return null;
+  }
+  const found = await docService.findOne({
+    documentId: cleanStr,
+    populate: ["createdBy", "updatedBy"]
+  });
+  return found ?? null;
+}
+async function persistCreatedNote(strapi, createData, actor) {
+  const dbQuery = getDbQuery(strapi);
+  if (dbQuery && typeof dbQuery.create === "function") {
+    const created = await dbQuery.create({
+      data: createData,
+      populate: ["createdBy", "updatedBy"]
+    });
+    return normalizeNoteRecord({
+      ...created,
+      createdBy: resolvePopulatedAuthor(created.createdBy, actor),
+      updatedBy: resolvePopulatedAuthor(created.updatedBy, actor)
+    });
+  }
+  const docService = getDocService(strapi);
+  if (docService && typeof docService.create === "function") {
+    const created = await docService.create({
+      data: createData,
+      populate: ["createdBy", "updatedBy"]
+    });
+    return normalizeNoteRecord({
+      ...created,
+      createdBy: resolvePopulatedAuthor(created.createdBy, actor),
+      updatedBy: resolvePopulatedAuthor(created.updatedBy, actor)
+    });
+  }
+  return null;
+}
+async function persistUpdatedNote(strapi, existing, updateData, actor) {
+  const dbQuery = getDbQuery(strapi);
+  if (dbQuery && typeof dbQuery.update === "function" && existing.id !== void 0) {
+    const updated = await dbQuery.update({
+      where: { id: existing.id },
+      data: updateData,
+      populate: ["createdBy", "updatedBy"]
+    });
+    return updated ? mergeUpdatedNoteRecord(existing, updated, actor) : null;
+  }
+  const docService = getDocService(strapi);
+  if (docService && typeof docService.update === "function" && existing.documentId) {
+    const updated = await docService.update({
+      documentId: String(existing.documentId),
+      data: updateData,
+      populate: ["createdBy", "updatedBy"]
+    });
+    return updated ? mergeUpdatedNoteRecord(existing, updated, actor) : null;
+  }
+  return null;
+}
+const notesService = ({ strapi }) => {
+  const memoryFallback = [];
+  let nextMemoryId = 1;
+  async function fetchRawNotes(filters) {
+    const where = buildDbWhereClause(filters);
+    const hasWhere = Object.keys(where).length > 0;
+    const sortDir = (filters.sort ?? "DESC").toLowerCase();
+    const dbQuery = getDbQuery(strapi);
+    if (dbQuery && typeof dbQuery.findMany === "function") {
+      const rows = await dbQuery.findMany({
+        ...hasWhere ? { where } : {},
+        populate: ["createdBy", "updatedBy"],
+        orderBy: { isPinned: "desc", createdAt: sortDir }
+      });
+      return Array.isArray(rows) ? rows : [];
+    }
+    const docService = getDocService(strapi);
+    if (docService && typeof docService.findMany === "function") {
+      const docs = await docService.findMany({
+        ...hasWhere ? { filters: where } : {},
+        populate: ["createdBy", "updatedBy"],
+        sort: { isPinned: "desc", createdAt: sortDir }
+      });
+      return Array.isArray(docs) ? docs : [];
+    }
+    return [...memoryFallback];
+  }
+  async function findRawNoteByIdentifier(identifier) {
+    const cleanStr = String(identifier ?? "").trim();
+    if (!cleanStr) {
+      return null;
+    }
+    const fromDb = await queryDbByIdentifier(strapi, cleanStr);
+    if (fromDb) return fromDb;
+    const fromDoc = await queryDocServiceByIdentifier(strapi, cleanStr);
+    if (fromDoc) return fromDoc;
+    if (hasExternalStorage(strapi)) {
+      return null;
+    }
+    const fromMemory = memoryFallback.find(
+      (item) => String(item.id) === cleanStr || String(item.documentId) === cleanStr
+    );
+    return fromMemory ?? null;
+  }
+  return {
+    async findWithMeta(rawQuery = {}) {
+      const pluginConfig = getNotesPluginConfig(strapi);
+      const filters = parseNoteQueryFilters(rawQuery, pluginConfig);
+      const rawList = await fetchRawNotes(filters);
+      const normalized = rawList.map((item) => normalizeNoteRecord(item));
+      const matched = filterNotesList(normalized, {
+        ...filters,
+        limit: void 0,
+        offset: void 0
+      });
+      const summary = computeNotesSummaryStats(matched);
+      const data = filterNotesList(matched, {
+        sort: filters.sort,
+        limit: filters.limit,
+        offset: filters.offset
+      });
+      return {
+        data,
+        total: matched.length,
+        summary
+      };
+    },
+    async find(rawQuery = {}) {
+      const { data } = await this.findWithMeta(rawQuery);
+      return data;
+    },
+    async findOne(identifier) {
+      const found = await findRawNoteByIdentifier(identifier);
+      return found ? normalizeNoteRecord(found) : null;
+    },
+    async getSummaryStats(rawQuery = {}) {
+      const { summary } = await this.findWithMeta(rawQuery);
+      return summary;
+    },
+    async create(input, actorUser) {
+      const validation = validateNoteCreatePayload(input);
+      if (!validation.valid) {
+        throw new NotesValidationError(validation.errors);
+      }
+      const pluginConfig = getNotesPluginConfig(strapi);
+      const actor = sanitizeNoteAuthor(actorUser);
+      const actorName = hasNamedActorDisplay(actor) ? actor?.displayName ?? "" : "";
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const numericEntityId = toSqlInt32(validation.data.entityId);
+      const createData = {
+        title: validation.data.title,
+        content: validation.data.content,
+        category: validation.data.category,
+        isPinned: validation.data.isPinned,
+        entitySlug: validation.data.entitySlug,
+        entityId: numericEntityId,
+        entityDocumentId: validation.data.entityDocumentId,
+        entityLocale: pluginConfig.enableLocaleScoping ? validation.data.entityLocale : null,
+        createdByName: actorName,
+        updatedByName: actorName
+      };
+      if (actor?.id !== null && actor?.id !== void 0) {
+        createData.createdBy = actor.id;
+        createData.updatedBy = actor.id;
+      }
+      const persisted = await persistCreatedNote(strapi, createData, actor);
+      if (persisted) {
+        return persisted;
+      }
+      const memId = nextMemoryId++;
+      const record = {
+        id: memId,
+        documentId: `note_${memId}`,
+        ...createData,
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        createdBy: actor,
+        updatedBy: actor
+      };
+      memoryFallback.push(record);
+      return normalizeNoteRecord(record);
+    },
+    async update(identifier, input, actorUser) {
+      const validation = validateNoteUpdatePayload(input);
+      if (!validation.valid) {
+        throw new NotesValidationError(validation.errors);
+      }
+      const existing = await findRawNoteByIdentifier(identifier);
+      if (!existing) {
+        return null;
+      }
+      const pluginConfig = getNotesPluginConfig(strapi);
+      const actor = sanitizeNoteAuthor(actorUser);
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const updateData = {
+        ...validation.data
+      };
+      if ("entityId" in updateData) {
+        const rawEntityId = updateData.entityId;
+        updateData.entityId = toSqlInt32(rawEntityId);
+        if (updateData.entityId === null && rawEntityId !== null && rawEntityId !== void 0 && !updateData.entityDocumentId && !existing.entityDocumentId) {
+          updateData.entityDocumentId = String(rawEntityId);
+        }
+      }
+      if (!pluginConfig.enableLocaleScoping && "entityLocale" in validation.data) {
+        updateData.entityLocale = null;
+      }
+      if (hasNamedActorDisplay(actor) && actor?.displayName) {
+        updateData.updatedByName = actor.displayName;
+      }
+      if (actor?.id !== null && actor?.id !== void 0) {
+        updateData.updatedBy = actor.id;
+      }
+      if (hasExternalStorage(strapi)) {
+        return persistUpdatedNote(strapi, existing, updateData, actor);
+      }
+      const memIndex = memoryFallback.findIndex(
+        (item) => String(item.id) === String(existing.id) || String(item.documentId) === String(existing.documentId)
+      );
+      const merged = {
+        ...existing,
+        ...updateData,
+        updatedAt: nowIso,
+        updatedBy: resolvePopulatedAuthor(actor, existing.updatedBy)
+      };
+      if (memIndex >= 0) {
+        memoryFallback[memIndex] = merged;
+      }
+      return normalizeNoteRecord(merged);
+    },
+    async delete(identifier) {
+      const existing = await findRawNoteByIdentifier(identifier);
+      if (!existing) {
+        return null;
+      }
+      const normalized = normalizeNoteRecord(existing);
+      const dbQuery = getDbQuery(strapi);
+      if (dbQuery && typeof dbQuery.delete === "function" && existing.id !== void 0) {
+        await dbQuery.delete({
+          where: { id: existing.id }
+        });
+        return normalized;
+      }
+      const docService = getDocService(strapi);
+      if (docService && typeof docService.delete === "function" && existing.documentId) {
+        await docService.delete({
+          documentId: String(existing.documentId)
+        });
+        return normalized;
+      }
+      const memIndex = memoryFallback.findIndex(
+        (item) => String(item.id) === String(existing.id) || String(item.documentId) === String(existing.documentId)
+      );
+      if (memIndex >= 0) {
+        memoryFallback.splice(memIndex, 1);
+      }
+      return normalized;
+    }
+  };
+};
+function sendJson(ctx, payload, statusCode = 200) {
+  ctx.status = statusCode;
+  ctx.body = payload;
+  if (typeof ctx.send === "function" && statusCode === 200) {
+    ctx.send(payload);
+  }
+  return payload;
+}
+function sendBadRequest(ctx, message, details) {
+  if (typeof ctx.badRequest === "function") {
+    return ctx.badRequest(message, { errors: details ?? [message] });
+  }
+  return sendJson(
+    ctx,
+    {
+      data: null,
+      error: {
+        status: 400,
+        name: "ValidationError",
+        message,
+        details: { errors: details ?? [message] }
+      }
+    },
+    400
+  );
+}
+function sendNotFound(ctx, message = "Note not found.") {
+  if (typeof ctx.notFound === "function") {
+    return ctx.notFound(message);
+  }
+  return sendJson(
+    ctx,
+    {
+      data: null,
+      error: {
+        status: 404,
+        name: "NotFoundError",
+        message
+      }
+    },
+    404
+  );
+}
+const notesController = ({ strapi }) => {
+  const getService = () => strapi.plugin(PLUGIN_ID).service("notesService");
+  return {
+    async find(ctx) {
+      const query = ctx.query ?? {};
+      const service = getService();
+      if (typeof service.findWithMeta === "function") {
+        const { data, total, summary: summary2 } = await service.findWithMeta(query);
+        return sendJson(ctx, {
+          data,
+          meta: {
+            total,
+            summary: summary2
+          }
+        });
+      }
+      const notes = await service.find(query);
+      const summary = computeNotesSummaryStats(notes);
+      return sendJson(ctx, {
+        data: notes,
+        meta: {
+          total: notes.length,
+          summary
+        }
+      });
+    },
+    async stats(ctx) {
+      const query = ctx.query ?? {};
+      const summary = await getService().getSummaryStats(query);
+      return sendJson(ctx, { data: summary });
+    },
+    async findOne(ctx) {
+      const id = ctx.params?.id ?? "";
+      if (!id) {
+        return sendBadRequest(ctx, "Note identifier is required.");
+      }
+      const note = await getService().findOne(id);
+      if (!note) {
+        return sendNotFound(ctx);
+      }
+      return sendJson(ctx, { data: note });
+    },
+    async create(ctx) {
+      try {
+        const created = await getService().create(
+          ctx.request?.body ?? {},
+          ctx.state?.user
+        );
+        return sendJson(ctx, { data: created }, 201);
+      } catch (err) {
+        if (err instanceof NotesValidationError) {
+          return sendBadRequest(ctx, err.message, err.details);
+        }
+        throw err;
+      }
+    },
+    async update(ctx) {
+      const id = ctx.params?.id ?? "";
+      if (!id) {
+        return sendBadRequest(ctx, "Note identifier is required.");
+      }
+      try {
+        const updated = await getService().update(
+          id,
+          ctx.request?.body ?? {},
+          ctx.state?.user
+        );
+        if (!updated) {
+          return sendNotFound(ctx);
+        }
+        return sendJson(ctx, { data: updated });
+      } catch (err) {
+        if (err instanceof NotesValidationError) {
+          return sendBadRequest(ctx, err.message, err.details);
+        }
+        throw err;
+      }
+    },
+    async delete(ctx) {
+      const id = ctx.params?.id ?? "";
+      if (!id) {
+        return sendBadRequest(ctx, "Note identifier is required.");
+      }
+      const deleted = await getService().delete(id);
+      if (!deleted) {
+        return sendNotFound(ctx);
+      }
+      return sendJson(ctx, { data: deleted });
+    }
+  };
+};
+const controllers = {
+  notesController,
+  noteController: notesController,
+  note: notesController
+};
+const destroy = ({ strapi }) => {
+  strapi.log?.debug?.("[@vicacha-devs/strapi-plugin-notes] Destroyed plugin.");
+};
+const register = ({ strapi }) => {
+  strapi.log?.debug?.("[@vicacha-devs/strapi-plugin-notes] Registered plugin.");
+};
+const readPolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.read`] }
+  }
+];
+const updatePolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.update`] }
+  }
+];
+const deletePolicies = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: [`plugin::${PLUGIN_ID}.delete`] }
+  }
+];
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/notes",
+      handler: "notesController.find",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/notes/stats",
+      handler: "notesController.stats",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "GET",
+      path: "/notes/:id",
+      handler: "notesController.findOne",
+      config: {
+        policies: readPolicies
+      }
+    },
+    {
+      method: "POST",
+      path: "/notes",
+      handler: "notesController.create",
+      config: {
+        policies: updatePolicies
+      }
+    },
+    {
+      method: "PUT",
+      path: "/notes/:id",
+      handler: "notesController.update",
+      config: {
+        policies: updatePolicies
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/notes/:id",
+      handler: "notesController.delete",
+      config: {
+        policies: deletePolicies
+      }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/notes",
+      handler: "notesController.find",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/notes/:id",
+      handler: "notesController.findOne",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+const services = {
+  notesService,
+  noteService: notesService,
+  note: notesService
+};
+const plugin = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes
+};
+export {
+  plugin as default
+};