@vicacha-devs/strapi-plugin-global-search 0.0.0-stage → 2.0.3

package/dist/server/index.mjs

@@ -0,0 +1,1186 @@
+// server/utils/constants.ts
+var PLUGIN_ID = "global-search";
+var SEARCHABLE_SCALAR_TYPES = [
+  "string",
+  "text",
+  "richtext",
+  "customField",
+  "uid",
+  "email",
+  "enumeration"
+];
+var SYSTEM_PLUGIN_PREFIXES = [
+  "plugin::upload.",
+  "plugin::i18n.",
+  "plugin::users-permissions.",
+  "plugin::content-releases.",
+  "plugin::review-workflows.",
+  "plugin::navigation.",
+  "plugin::config-sync.",
+  "plugin::email-designer-5.",
+  "plugin::publisher.",
+  "plugin::seo.",
+  "plugin::tiptap-editor.",
+  "plugin::global-search."
+];
+var SKIPPED_ATTRIBUTE_TYPES = [
+  "dynamiczone",
+  "blocks",
+  "json",
+  "relation",
+  "media",
+  "password"
+];
+var BLOCKLISTED_ATTRIBUTE_NAMES = [
+  "password",
+  "resetPasswordToken",
+  "registrationToken",
+  "confirmationToken"
+];
+var IDENTIFIER_FIELDS = [
+  "uid",
+  "slug",
+  "code",
+  "key",
+  "referenceCode",
+  "bookingCode",
+  "certificateNumber",
+  "transactionReference"
+];
+var MAIN_FIELD_FALLBACKS = [
+  "name",
+  "title",
+  "label",
+  "displayName",
+  "heading",
+  "heroTitle",
+  "question",
+  "term",
+  "subject",
+  "fullName",
+  "applicantName",
+  "customerName",
+  "donorName",
+  "referenceCode",
+  "bookingCode",
+  "certificateNumber",
+  "slug"
+];
+var TIER = {
+  ID_EXACT: 0,
+  ID_CONTAINS: 1,
+  MAIN_EXACT: 2,
+  MAIN_STARTS_WITH: 3,
+  MAIN_CONTAINS: 4,
+  FIELD_CONTAINS: 5,
+  NESTED_CONTAINS: 6,
+  UNKNOWN: 7
+};
+var TIER_LABELS = {
+  0: "id:exact",
+  1: "id:partial",
+  2: "name:exact",
+  3: "name:starts-with",
+  4: "name:partial",
+  5: "field",
+  6: "nested-field",
+  7: "other"
+};
+var MAX_QUERY_LENGTH = 200;
+var SNIPPET_RADIUS = 45;
+
+// server/bootstrap.ts
+var bootstrap_default = async ({ strapi }) => {
+  try {
+    const types = await strapi.plugin(PLUGIN_ID).service("schema").getSearchableContentTypes();
+    const uidList = types.map((type) => type.uid).join(", ");
+    strapi.log.debug(
+      `[${PLUGIN_ID}] indexed ${types.length} content type(s): ${uidList}`
+    );
+  } catch (error) {
+    const msg = error.message;
+    strapi.log.error(
+      `[${PLUGIN_ID}] failed to introspect content types: ${msg}`
+    );
+  }
+};
+
+// server/config/index.ts
+var defaults = {
+  /** Minimum number of characters before a search is executed. */
+  minChars: 2,
+  /** Client-side debounce, in ms. Served to the admin so both UIs stay in sync. */
+  debounce: 250,
+  /** Maximum rows fetched per content type, per search. */
+  perTypeLimit: 20,
+  /** Hard cap on the merged, ranked result set. */
+  maxResults: 100,
+  /** Search inside nested component fields. */
+  deep: true,
+  /** How many component levels to walk when collecting searchable paths. */
+  maxDepth: 3,
+  /** Include unpublished entries (draft & publish types). */
+  includeDrafts: true,
+  /** Include Content-Manager-visible content types registered by plugins (plugin::*). */
+  includePluginContentTypes: true,
+  /** Per-content-type query timeout, in ms. */
+  queryTimeout: 4e3,
+  /** Maximum number of content types queried in parallel. */
+  concurrency: 8,
+  /** Content type UIDs never searched. */
+  excludedContentTypes: [],
+  /** Field paths never searched, as `uid:path` (e.g. `api::article.article:body`). */
+  excludedFields: [],
+  /** Up to two extra fields shown next to the main field, keyed by content type UID. */
+  displayFields: {}
+};
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var validator = (config2 = {}) => {
+  if (!isPlainObject(config2)) {
+    throw new Error("[global-search] config must be a plain object");
+  }
+  const numbers = {
+    minChars: [1, 10],
+    debounce: [0, 5e3],
+    perTypeLimit: [1, 200],
+    maxResults: [1, 1e3],
+    maxDepth: [1, 6],
+    queryTimeout: [500, 6e4],
+    concurrency: [1, 32]
+  };
+  Object.entries(numbers).forEach(([key, [min, max]]) => {
+    if (config2[key] === void 0) return;
+    const value = config2[key];
+    if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+      throw new Error(
+        `[global-search] config.${key} must be an integer between ${min} and ${max}`
+      );
+    }
+  });
+  ["deep", "includeDrafts", "includePluginContentTypes"].forEach(
+    (key) => {
+      if (config2[key] !== void 0 && typeof config2[key] !== "boolean") {
+        throw new Error(`[global-search] config.${key} must be a boolean`);
+      }
+    }
+  );
+  ["excludedContentTypes", "excludedFields"].forEach((key) => {
+    if (config2[key] !== void 0 && !isStringArray(config2[key])) {
+      throw new Error(
+        `[global-search] config.${key} must be an array of strings`
+      );
+    }
+  });
+  if (config2.displayFields !== void 0) {
+    const validMap = isPlainObject(config2.displayFields) && Object.values(config2.displayFields).every(isStringArray);
+    if (!validMap) {
+      throw new Error(
+        "[global-search] config.displayFields must map content type UIDs to string arrays"
+      );
+    }
+  }
+};
+var config = {
+  default: defaults,
+  validator,
+  defaults
+};
+var config_default = config;
+
+// server/controllers/schema.ts
+var collectAllFields = (type) => {
+  const main = type.mainField && type.mainField !== "id" && type.mainFieldSearchable !== false ? [type.mainField] : [];
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      ...type.idFields,
+      ...main,
+      ...type.topLevelFields,
+      ...type.nestedFields
+    ])
+  );
+};
+var toSummary = (type) => ({
+  uid: type.uid,
+  kind: type.kind,
+  displayName: type.displayName,
+  mainField: type.mainField,
+  localized: type.localized,
+  draftAndPublish: type.draftAndPublish,
+  fieldCount: collectAllFields(type).length,
+  searchable: type.searchable
+});
+var schema_default = ({ strapi }) => ({
+  /** Powers the content-type filter chips on the search page. */
+  async find(ctx) {
+    const types = await strapi.plugin(PLUGIN_ID).service("schema").getSearchableContentTypes();
+    const readable = strapi.plugin(PLUGIN_ID).service("permissions").filterReadableTypes(types, ctx.state.userAbility);
+    const settings = await strapi.plugin(PLUGIN_ID).service("settings").get();
+    ctx.body = {
+      contentTypes: readable.map(toSummary),
+      settings: { minChars: settings.minChars, debounce: settings.debounce }
+    };
+  },
+  /** Full picture, including excluded and unsearchable types, for Settings. */
+  async findAll(ctx) {
+    const types = await strapi.plugin(PLUGIN_ID).service("schema").getAllContentTypes();
+    const settings = await strapi.plugin(PLUGIN_ID).service("settings").get();
+    ctx.body = {
+      contentTypes: types.map((type) => ({
+        ...toSummary(type),
+        excluded: (settings.excludedContentTypes || []).includes(type.uid),
+        fields: collectAllFields(type)
+      }))
+    };
+  }
+});
+
+// server/controllers/search.ts
+var toArray = (value) => {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => String(item).split(",")).map((item) => item.trim()).filter(Boolean);
+  }
+  if (typeof value === "object") {
+    return Object.values(value).flatMap((item) => String(item).split(",")).map((item) => item.trim()).filter(Boolean);
+  }
+  return String(value).split(",").map((item) => item.trim()).filter(Boolean);
+};
+var search_default = ({ strapi }) => ({
+  async find(ctx) {
+    const { q, locale, page, pageSize } = ctx.request.query;
+    const rawTypes = ctx.request.query.types ?? ctx.request.query["types[]"];
+    try {
+      ctx.body = await strapi.plugin(PLUGIN_ID).service("search").search({
+        query: typeof q === "string" ? q : void 0,
+        types: toArray(rawTypes),
+        locale: typeof locale === "string" ? locale : void 0,
+        page: page !== void 0 ? Number(page) : void 0,
+        pageSize: pageSize !== void 0 ? Number(pageSize) : void 0,
+        userAbility: ctx.state.userAbility
+      });
+    } catch (error) {
+      const detail = error.stack || error.message;
+      strapi.log.error(`[${PLUGIN_ID}] search request failed: ${detail}`);
+      ctx.throw(
+        500,
+        "Global search failed. Check the server logs for details."
+      );
+    }
+  }
+});
+
+// server/controllers/settings.ts
+var settings_default = ({ strapi }) => ({
+  async find(ctx) {
+    ctx.body = await strapi.plugin(PLUGIN_ID).service("settings").get();
+  },
+  async update(ctx) {
+    try {
+      ctx.body = await strapi.plugin(PLUGIN_ID).service("settings").set(ctx.request.body || {});
+    } catch (error) {
+      ctx.throw(400, error.message);
+    }
+  },
+  async reset(ctx) {
+    ctx.body = await strapi.plugin(PLUGIN_ID).service("settings").reset();
+  }
+});
+
+// server/controllers/index.ts
+var controllers_default = {
+  search: search_default,
+  schema: schema_default,
+  settings: settings_default
+};
+
+// server/register.ts
+var RBAC_ACTIONS = [
+  {
+    section: "plugins",
+    displayName: "Search content",
+    uid: "read",
+    pluginName: PLUGIN_ID
+  },
+  {
+    section: "settings",
+    category: "global search",
+    subCategory: "general",
+    displayName: "Configure global search",
+    uid: "settings",
+    pluginName: PLUGIN_ID
+  }
+];
+var register_default = ({ strapi }) => {
+  strapi.admin?.services?.permission?.actionProvider?.registerMany(
+    RBAC_ACTIONS
+  );
+};
+
+// server/routes/index.ts
+var withPermission = (action) => ({
+  policies: [
+    {
+      name: "admin::hasPermissions",
+      config: { actions: [`plugin::${PLUGIN_ID}.${action}`] }
+    }
+  ]
+});
+var routes_default = {
+  admin: {
+    type: "admin",
+    routes: [
+      {
+        method: "GET",
+        path: "/search",
+        handler: "search.find",
+        config: withPermission("read")
+      },
+      {
+        method: "GET",
+        path: "/schema",
+        handler: "schema.find",
+        config: withPermission("read")
+      },
+      {
+        method: "GET",
+        path: "/schema/all",
+        handler: "schema.findAll",
+        config: withPermission("settings")
+      },
+      {
+        method: "GET",
+        path: "/settings",
+        handler: "settings.find",
+        config: withPermission("settings")
+      },
+      {
+        method: "PUT",
+        path: "/settings",
+        handler: "settings.update",
+        config: withPermission("settings")
+      },
+      {
+        method: "POST",
+        path: "/settings/reset",
+        handler: "settings.reset",
+        config: withPermission("settings")
+      }
+    ]
+  }
+};
+
+// server/services/permissions.ts
+var CM_READ_ACTION = "plugin::content-manager.explorer.read";
+var permissions_default = () => ({
+  /**
+   * An editor restricted to Articles must not discover Orders through search, so
+   * candidate types are intersected with what the caller can read in the Content
+   * Manager before any query runs.
+   */
+  filterReadableTypes(types, userAbility) {
+    if (!userAbility || typeof userAbility.can !== "function") return types;
+    return types.filter((type) => {
+      try {
+        return userAbility.can(CM_READ_ACTION, type.uid);
+      } catch {
+        return false;
+      }
+    });
+  }
+});
+
+// server/services/query.ts
+var nest = (path, condition) => path.split(".").reduceRight(
+  (acc, segment) => ({ [segment]: acc }),
+  condition
+);
+var buildPopulate = (paths) => {
+  const tree = {};
+  paths.forEach((path) => {
+    const segments = path.split(".");
+    segments.pop();
+    let node = tree;
+    segments.forEach((segment) => {
+      node[segment] = node[segment] || {};
+      node = node[segment];
+    });
+  });
+  const toPopulate = (node) => Object.entries(node).reduce(
+    (acc, [key, child]) => {
+      const childObj = child;
+      acc[key] = Object.keys(childObj).length ? { populate: toPopulate(childObj) } : true;
+      return acc;
+    },
+    {}
+  );
+  return Object.keys(tree).length ? toPopulate(tree) : void 0;
+};
+var MAX_PG_INT32 = 2147483647;
+var query_default = () => ({
+  nest,
+  buildPopulate,
+  /** All field paths a hit could have matched, in ranking order. */
+  searchablePaths(descriptor) {
+    const main = descriptor.mainField && descriptor.mainField !== "id" && descriptor.mainFieldSearchable !== false ? [descriptor.mainField] : [];
+    return Array.from(
+      /* @__PURE__ */ new Set([
+        ...descriptor.idFields,
+        ...main,
+        ...descriptor.topLevelFields,
+        ...descriptor.nestedFields
+      ])
+    );
+  },
+  /**
+   * One `$or` over every searchable path. `id` is numeric, so it is only added —
+   * as an equality — when the query is a plain integer within 32-bit Postgres INT
+   * bounds; `$containsi` on an integer column is rejected by Postgres.
+   * `documentId` is matched as a string unless excluded.
+   */
+  buildFilters(descriptor, query) {
+    const paths = this.searchablePaths(descriptor);
+    const conditions = [];
+    if (paths.includes("documentId")) {
+      conditions.push({ documentId: { $containsi: query } });
+    }
+    if (/^\d+$/.test(query)) {
+      const numericId = Number(query);
+      if (Number.isSafeInteger(numericId) && numericId >= 1 && numericId <= MAX_PG_INT32) {
+        conditions.push({ id: { $eq: numericId } });
+      }
+    }
+    paths.forEach((path) => {
+      if (path === "documentId") return;
+      conditions.push(nest(path, { $containsi: query }));
+    });
+    return conditions.length ? { $or: conditions } : null;
+  },
+  /** Bounded projection — never `populate: '*'`, never a full row. */
+  buildParams(descriptor, {
+    query,
+    locale,
+    limit,
+    includeDrafts
+  }) {
+    const filters = this.buildFilters(descriptor, query);
+    if (!filters) return null;
+    const fields = Array.from(
+      new Set(
+        [
+          "documentId",
+          ...descriptor.idFields,
+          descriptor.mainField,
+          ...descriptor.topLevelFields,
+          ...descriptor.displayFields || [],
+          "createdAt",
+          "updatedAt",
+          ...descriptor.draftAndPublish ? ["publishedAt"] : [],
+          ...descriptor.localized ? ["locale"] : []
+        ].filter((field) => field && field !== "id")
+      )
+    );
+    const params = {
+      filters,
+      fields,
+      sort: { updatedAt: "desc" },
+      limit,
+      start: 0
+    };
+    const populate = buildPopulate(descriptor.nestedFields);
+    if (populate) params.populate = populate;
+    if (descriptor.draftAndPublish) {
+      params.status = includeDrafts ? "draft" : "published";
+    }
+    if (descriptor.localized) {
+      params.locale = locale && locale !== "all" ? locale : "*";
+    }
+    return params;
+  }
+});
+
+// server/utils/text.ts
+var MAX_DOC_DEPTH = 32;
+var MAX_STRUCTURED_CHARS = 5e5;
+var sanitizeQuery = (raw) => {
+  if (typeof raw !== "string") return "";
+  const cleaned = raw.replace(/%/g, "").trim().slice(0, MAX_QUERY_LENGTH);
+  return /^[_\s]+$/.test(cleaned) ? "" : cleaned;
+};
+var isProseMirrorRoot = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.type === "doc" && Array.isArray(obj.content)) return true;
+  if (obj.doc && typeof obj.doc === "object" && !Array.isArray(obj.doc)) {
+    const inner = obj.doc;
+    return inner.type === "doc" && Array.isArray(inner.content);
+  }
+  return false;
+};
+var walkDocNodes = (node, chunks, depth = 0, visited = /* @__PURE__ */ new WeakSet()) => {
+  if (!node || depth > MAX_DOC_DEPTH) return;
+  if (Array.isArray(node)) {
+    if (visited.has(node)) return;
+    visited.add(node);
+    node.forEach((child) => walkDocNodes(child, chunks, depth + 1, visited));
+    return;
+  }
+  if (typeof node !== "object") return;
+  if (visited.has(node)) return;
+  visited.add(node);
+  const obj = node;
+  if (typeof obj.text === "string" && obj.text.trim()) {
+    chunks.push(obj.text);
+  }
+  if (obj.doc && typeof obj.doc === "object") {
+    walkDocNodes(obj.doc, chunks, depth + 1, visited);
+  }
+  if (Array.isArray(obj.content)) {
+    walkDocNodes(obj.content, chunks, depth + 1, visited);
+  }
+  if (Array.isArray(obj.children)) {
+    walkDocNodes(obj.children, chunks, depth + 1, visited);
+  }
+};
+var extractStructuredText = (value) => {
+  let candidate = value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") || trimmed.length > MAX_STRUCTURED_CHARS) {
+      return null;
+    }
+    try {
+      candidate = JSON.parse(trimmed);
+    } catch {
+      return null;
+    }
+  }
+  if (!isProseMirrorRoot(candidate)) return null;
+  const chunks = [];
+  walkDocNodes(candidate, chunks);
+  return chunks.join(" ").replace(/\s+/g, " ").trim();
+};
+var stripHtmlTags = (input) => {
+  let out = "";
+  let tagStart = -1;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (ch === "<") {
+      if (tagStart !== -1) {
+        out += input.slice(tagStart, i);
+      }
+      tagStart = i;
+    } else if (ch === ">" && tagStart !== -1) {
+      out += " ";
+      tagStart = -1;
+    } else if (tagStart === -1) {
+      out += ch;
+    }
+  }
+  if (tagStart !== -1) {
+    out += input.slice(tagStart);
+  }
+  return out;
+};
+var toPlainText = (value) => {
+  if (value === null || value === void 0) return "";
+  const structured = extractStructuredText(value);
+  if (structured !== null) return structured;
+  return stripHtmlTags(String(value)).replace(/[#*_>`~]+/g, " ").replace(/\s+/g, " ").trim();
+};
+var collectValues = (node, parts) => {
+  if (node === null || node === void 0) return [];
+  if (Array.isArray(node))
+    return node.flatMap((item) => collectValues(item, parts));
+  if (parts.length === 0) {
+    const structured = extractStructuredText(node);
+    if (structured !== null) return structured ? [structured] : [];
+    if (typeof node === "string") return [node];
+    if (typeof node === "number") return [String(node)];
+    return [];
+  }
+  if (typeof node !== "object") return [];
+  return collectValues(
+    node[parts[0]],
+    parts.slice(1)
+  );
+};
+var getValuesAtPath = (entry, path) => collectValues(entry, path.split("."));
+var buildSnippet = (value, query) => {
+  const text = toPlainText(value);
+  const index = text.toLowerCase().indexOf(query.toLowerCase());
+  if (index === -1) {
+    return text.length > SNIPPET_RADIUS * 2 ? `${text.slice(0, SNIPPET_RADIUS * 2)}\u2026` : text;
+  }
+  const start = Math.max(0, index - SNIPPET_RADIUS);
+  const end = Math.min(text.length, index + query.length + SNIPPET_RADIUS);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < text.length ? "\u2026" : "";
+  return `${prefix}${text.slice(start, end)}${suffix}`;
+};
+var humanizeFieldPath = (path) => path.split(".").map(
+  (segment) => segment.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase())
+).join(" \u203A ");
+
+// server/services/ranking.ts
+var ranking_default = () => ({
+  /** First path whose value satisfies `test`, searched in the given order. */
+  findMatch(entry, paths, test, normalize = false) {
+    for (const path of paths) {
+      const values = getValuesAtPath(entry, path);
+      for (const rawValue of values) {
+        const value = normalize ? toPlainText(rawValue) || rawValue : rawValue;
+        if (test(value)) return { path, value };
+      }
+    }
+    return null;
+  },
+  score(entry, descriptor, query) {
+    const lowered = query.toLowerCase();
+    const idSet = /* @__PURE__ */ new Set(["id", ...descriptor.idFields]);
+    const idPaths = Array.from(idSet);
+    const mainPaths = descriptor.mainField && descriptor.mainField !== "id" && descriptor.mainFieldSearchable !== false ? [descriptor.mainField] : [];
+    const attempts = [
+      [TIER.ID_EXACT, idPaths, (val) => val.toLowerCase() === lowered, false],
+      [
+        TIER.ID_CONTAINS,
+        idPaths,
+        (val) => val.toLowerCase().includes(lowered),
+        false
+      ],
+      [
+        TIER.MAIN_EXACT,
+        mainPaths,
+        (val) => val.toLowerCase() === lowered,
+        true
+      ],
+      [
+        TIER.MAIN_STARTS_WITH,
+        mainPaths,
+        (val) => val.toLowerCase().startsWith(lowered),
+        true
+      ],
+      [
+        TIER.MAIN_CONTAINS,
+        mainPaths,
+        (val) => val.toLowerCase().includes(lowered),
+        true
+      ],
+      [
+        TIER.FIELD_CONTAINS,
+        descriptor.topLevelFields,
+        (val) => val.toLowerCase().includes(lowered),
+        true
+      ],
+      [
+        TIER.NESTED_CONTAINS,
+        descriptor.nestedFields,
+        (val) => val.toLowerCase().includes(lowered),
+        true
+      ]
+    ];
+    for (const [tier, paths, test, normalize] of attempts) {
+      const match = this.findMatch(entry, paths, test, normalize);
+      if (match) {
+        return {
+          tier,
+          tierLabel: TIER_LABELS[tier],
+          matchedField: match.path,
+          matchedFieldLabel: humanizeFieldPath(match.path),
+          matchedSnippet: buildSnippet(match.value, query),
+          exactCase: match.value.includes(query),
+          valueLength: match.value.length
+        };
+      }
+    }
+    return {
+      tier: TIER.UNKNOWN,
+      tierLabel: TIER_LABELS[TIER.UNKNOWN],
+      matchedField: null,
+      matchedFieldLabel: null,
+      matchedSnippet: null,
+      exactCase: false,
+      valueLength: Number.MAX_SAFE_INTEGER
+    };
+  },
+  compare(a, b) {
+    if (a.tier !== b.tier) return a.tier - b.tier;
+    if (a.exactCase !== b.exactCase) return a.exactCase ? -1 : 1;
+    if (a.valueLength !== b.valueLength) return a.valueLength - b.valueLength;
+    return new Date(b.updatedAt || 0).getTime() - new Date(a.updatedAt || 0).getTime();
+  },
+  sort(hits) {
+    return [...hits].sort((a, b) => this.compare(a, b));
+  }
+});
+
+// server/services/schema.ts
+var schema_default2 = ({ strapi }) => {
+  let cache = null;
+  const computeSignature = (settings) => JSON.stringify({
+    settings,
+    uids: Object.keys(strapi.contentTypes).sort()
+  });
+  return {
+    /**
+     * Content types the plugin is allowed to look at: the app's own `api::` types
+     * plus user-facing `plugin::` types (excluding internal Strapi system plugins
+     * and types explicitly hidden from the Content Manager).
+     */
+    listCandidateUids(includePluginContentTypes = true) {
+      return Object.keys(strapi.contentTypes).filter((uid) => {
+        if (uid.startsWith("api::")) return true;
+        if (!includePluginContentTypes || !uid.startsWith("plugin::"))
+          return false;
+        if (SYSTEM_PLUGIN_PREFIXES.some((prefix) => uid.startsWith(prefix)))
+          return false;
+        const contentType = strapi.contentTypes[uid];
+        if (contentType?.pluginOptions?.["content-manager"]?.visible === false)
+          return false;
+        return true;
+      });
+    },
+    isSearchableAttribute(name, attribute) {
+      if (!attribute || BLOCKLISTED_ATTRIBUTE_NAMES.includes(name))
+        return false;
+      if (attribute.private === true) return false;
+      if (attribute.searchable === false) return false;
+      if (attribute.type && SKIPPED_ATTRIBUTE_TYPES.includes(attribute.type))
+        return false;
+      return Boolean(
+        attribute.type && SEARCHABLE_SCALAR_TYPES.includes(attribute.type)
+      );
+    },
+    isSafeDisplayAttribute(name, attribute) {
+      if (!name || typeof name !== "string") return false;
+      if (BLOCKLISTED_ATTRIBUTE_NAMES.includes(name)) return false;
+      if (!attribute || attribute.private === true) return false;
+      if (attribute.type && SKIPPED_ATTRIBUTE_TYPES.includes(attribute.type))
+        return false;
+      return true;
+    },
+    /**
+     * Flattens an attribute map into dotted, searchable field paths, walking into
+     * components up to `maxDepth`. `visited` breaks component cycles (a component
+     * that, directly or not, contains itself).
+     */
+    collectFieldPaths(attributes = {}, {
+      maxDepth,
+      depth = 0,
+      prefix = "",
+      visited = /* @__PURE__ */ new Set()
+    } = {
+      maxDepth: 0
+    }) {
+      const paths = [];
+      Object.entries(attributes).forEach(([name, attribute]) => {
+        const path = prefix ? `${prefix}.${name}` : name;
+        if (this.isSearchableAttribute(name, attribute)) {
+          paths.push(path);
+          return;
+        }
+        if (attribute.type !== "component" || depth >= maxDepth) return;
+        const component = strapi.components[attribute.component];
+        if (!component || !attribute.component || visited.has(attribute.component))
+          return;
+        paths.push(
+          ...this.collectFieldPaths(component.attributes, {
+            maxDepth,
+            depth: depth + 1,
+            prefix: path,
+            visited: /* @__PURE__ */ new Set([...visited, attribute.component])
+          })
+        );
+      });
+      return paths;
+    },
+    /** Resolves the field the Content Manager uses to label an entry. */
+    async resolveMainField(contentType) {
+      try {
+        const configuration = await strapi.plugin("content-manager").service("content-types").findConfiguration(contentType);
+        const mainField = configuration && configuration.settings && configuration.settings.mainField;
+        if (mainField && mainField !== "id" && this.isSafeDisplayAttribute(
+          mainField,
+          contentType.attributes?.[mainField]
+        )) {
+          return mainField;
+        }
+      } catch (error) {
+        const msg = error.message;
+        strapi.log.debug(
+          `[${PLUGIN_ID}] CM config read failed (${contentType.uid}): ${msg}`
+        );
+      }
+      const fallback = MAIN_FIELD_FALLBACKS.find(
+        (name) => this.isSearchableAttribute(name, contentType.attributes?.[name])
+      );
+      return fallback || "id";
+    },
+    extractExcludedFields(uid, excludedFields) {
+      return new Set(
+        (excludedFields || []).filter(
+          (entry) => typeof entry === "string" && (entry.startsWith(`${uid}:`) || entry.startsWith(`${uid}.`))
+        ).map((entry) => entry.slice(uid.length + 1))
+      );
+    },
+    resolveDisplayName(uid, info) {
+      return info?.displayName || info?.singularName || uid;
+    },
+    hasAnySearchableField(fields, isMainSearchable) {
+      if (fields.idFields.length > 0 || fields.topLevelFields.length > 0)
+        return true;
+      return fields.nestedFields.length > 0 || isMainSearchable;
+    },
+    async describeContentType(uid, settings) {
+      const contentType = strapi.contentTypes[uid];
+      if (!contentType) return null;
+      const attributes = contentType.attributes || {};
+      const excludedForType = this.extractExcludedFields(
+        uid,
+        settings.excludedFields
+      );
+      const allPaths = this.collectFieldPaths(attributes, {
+        maxDepth: settings.maxDepth
+      }).filter((path) => !excludedForType.has(path));
+      const mainField = await this.resolveMainField(contentType);
+      const mainFieldSearchable = !excludedForType.has(mainField) && this.isSearchableAttribute(mainField, attributes[mainField]);
+      const idFields = [
+        "documentId",
+        ...IDENTIFIER_FIELDS.filter(
+          (name) => this.isSearchableAttribute(name, attributes[name])
+        )
+      ].filter((name) => !excludedForType.has(name));
+      const topLevelFields = allPaths.filter(
+        (path) => !path.includes(".") && path !== mainField && !idFields.includes(path)
+      );
+      const nestedFields = settings.deep ? allPaths.filter((path) => path.includes(".")) : [];
+      const rawDisplay = settings.displayFields?.[uid];
+      const displayFields = Array.isArray(rawDisplay) ? rawDisplay.filter(
+        (name) => this.isSafeDisplayAttribute(name, attributes[name])
+      ).slice(0, 2) : [];
+      return {
+        uid,
+        kind: contentType.kind || "collectionType",
+        displayName: this.resolveDisplayName(uid, contentType.info),
+        apiName: contentType.apiName,
+        mainField,
+        mainFieldSearchable,
+        idFields,
+        topLevelFields,
+        nestedFields,
+        displayFields,
+        localized: Boolean(contentType.pluginOptions?.i18n?.localized),
+        draftAndPublish: Boolean(contentType.options?.draftAndPublish),
+        /** Nothing to match against — the type is listed but never queried. */
+        searchable: this.hasAnySearchableField(
+          { idFields, topLevelFields, nestedFields },
+          mainFieldSearchable
+        )
+      };
+    },
+    async getSearchableContentTypes({
+      force = false
+    } = {}) {
+      const settings = await strapi.plugin(PLUGIN_ID).service("settings").get();
+      const signature = computeSignature(settings);
+      if (cache && !force && cache.signature === signature) {
+        return cache.types;
+      }
+      const excluded = new Set(settings.excludedContentTypes || []);
+      const includePlugins = settings.includePluginContentTypes !== false;
+      const described = await Promise.all(
+        this.listCandidateUids(includePlugins).filter((uid) => !excluded.has(uid)).map((uid) => this.describeContentType(uid, settings))
+      );
+      const types = described.filter(
+        (type) => Boolean(type && type.searchable)
+      ).sort((a, b) => a.displayName.localeCompare(b.displayName));
+      cache = { signature, types };
+      return types;
+    },
+    /** Every candidate type, searchable or not — the Settings page needs the full list. */
+    async getAllContentTypes() {
+      const settings = await strapi.plugin(PLUGIN_ID).service("settings").get();
+      const includePlugins = settings.includePluginContentTypes !== false;
+      const described = await Promise.all(
+        this.listCandidateUids(includePlugins).map(
+          (uid) => this.describeContentType(uid, settings)
+        )
+      );
+      return described.filter((type) => Boolean(type)).sort((a, b) => a.displayName.localeCompare(b.displayName));
+    },
+    clearCache() {
+      cache = null;
+    }
+  };
+};
+
+// server/utils/async.ts
+var withTimeout = (factory, ms, label) => {
+  let timer;
+  return Promise.race([
+    Promise.resolve().then(factory).finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`GLOBAL_SEARCH_TIMEOUT:${label}`)),
+        ms
+      );
+    })
+  ]);
+};
+var mapWithConcurrency = async (items, concurrency, worker) => {
+  const results = Array.from({ length: items.length });
+  let cursor = 0;
+  const safeConcurrency = Math.max(1, Math.floor(Number(concurrency) || 1));
+  const runners = Array.from(
+    { length: Math.min(safeConcurrency, items.length) },
+    async () => {
+      while (cursor < items.length) {
+        const index = cursor;
+        cursor += 1;
+        results[index] = await worker(items[index], index);
+      }
+    }
+  );
+  await Promise.all(runners);
+  return results;
+};
+
+// server/services/search.ts
+var service = (strapi, name) => strapi.plugin(PLUGIN_ID).service(name);
+var search_default2 = ({ strapi }) => ({
+  /** Content Manager deep-link for a hit. */
+  buildAdminUrl(descriptor, entry) {
+    const localeQuery = entry.locale ? `?locale=${encodeURIComponent(entry.locale)}` : "";
+    if (descriptor.kind === "singleType") {
+      return `/content-manager/single-types/${descriptor.uid}${localeQuery}`;
+    }
+    const documentId = encodeURIComponent(String(entry.documentId || entry.id));
+    const base = `/content-manager/collection-types/${descriptor.uid}`;
+    return `${base}/${documentId}${localeQuery}`;
+  },
+  async queryContentType(descriptor, {
+    query,
+    locale,
+    settings
+  }) {
+    const params = service(strapi, "query").buildParams(descriptor, {
+      query,
+      locale,
+      limit: settings.perTypeLimit,
+      includeDrafts: settings.includeDrafts
+    });
+    if (!params) return [];
+    const result = await strapi.documents(descriptor.uid).findMany(params);
+    return Array.isArray(result) ? result : [result].filter(Boolean);
+  },
+  resolveEntryTitle(descriptor, entry) {
+    const mainVal = descriptor.mainField ? entry[descriptor.mainField] : "";
+    if (mainVal) return String(mainVal);
+    return String(
+      entry.name || entry.title || `#${entry.documentId || entry.id}`
+    );
+  },
+  resolveEntryStatus(descriptor, entry) {
+    if (!descriptor.draftAndPublish) return null;
+    return entry.publishedAt ? "published" : "draft";
+  },
+  toHit(descriptor, entry, query, settings) {
+    const scored = service(strapi, "ranking").score(entry, descriptor, query);
+    const rawExtra = descriptor.displayFields ?? (Array.isArray(settings.displayFields?.[descriptor.uid]) ? settings.displayFields[descriptor.uid] : []);
+    const extraFields = rawExtra.filter(
+      (field) => typeof field === "string" && Boolean(field) && !BLOCKLISTED_ATTRIBUTE_NAMES.includes(field)
+    ).slice(0, 2);
+    return {
+      ...scored,
+      contentTypeUid: descriptor.uid,
+      contentTypeLabel: descriptor.displayName,
+      kind: descriptor.kind,
+      id: entry.id,
+      documentId: entry.documentId || null,
+      title: this.resolveEntryTitle(descriptor, entry),
+      mainField: descriptor.mainField,
+      extra: extraFields.map((field) => ({
+        field,
+        value: entry[field] ?? null
+      })),
+      locale: entry.locale || null,
+      status: this.resolveEntryStatus(descriptor, entry),
+      updatedAt: entry.updatedAt || null,
+      adminUrl: this.buildAdminUrl(descriptor, entry)
+    };
+  },
+  /**
+   * Fans out across every permitted content type, ranks the merged set, then
+   * paginates in memory.
+   *
+   * `total` is the size of the *capped* merged set (`perTypeLimit` rows per type,
+   * `maxResults` overall), not a database count — searching for a common word in a
+   * 100k-row table must not turn into a full-table `COUNT`.
+   */
+  async search({
+    query: rawQuery,
+    types,
+    locale,
+    page = 1,
+    pageSize = 20,
+    userAbility
+  } = {}) {
+    const settings = await service(
+      strapi,
+      "settings"
+    ).get();
+    const query = sanitizeQuery(rawQuery);
+    const safePageSize = Math.min(
+      Math.max(Math.floor(Number(pageSize)) || 20, 1),
+      100
+    );
+    const empty = {
+      query,
+      results: [],
+      groups: [],
+      pagination: { page: 1, pageSize: safePageSize, total: 0, pageCount: 0 },
+      meta: {
+        searchedTypes: 0,
+        truncatedTypes: [],
+        failedTypes: [],
+        minChars: settings.minChars
+      }
+    };
+    if (query.length < settings.minChars) return empty;
+    const searchable = await service(
+      strapi,
+      "schema"
+    ).getSearchableContentTypes();
+    const requested = Array.isArray(types) && types.length ? new Set(types) : null;
+    const candidates = service(strapi, "permissions").filterReadableTypes(searchable, userAbility).filter(
+      (descriptor) => !requested || requested.has(descriptor.uid)
+    );
+    if (!candidates.length) return { ...empty, query };
+    const truncatedTypes = [];
+    const failedTypes = [];
+    const perType = await mapWithConcurrency(
+      candidates,
+      settings.concurrency,
+      async (descriptor) => {
+        try {
+          const entries = await withTimeout(
+            () => this.queryContentType(descriptor, { query, locale, settings }),
+            settings.queryTimeout,
+            descriptor.uid
+          );
+          if (entries.length >= settings.perTypeLimit)
+            truncatedTypes.push(descriptor.uid);
+          return entries.map(
+            (entry) => this.toHit(descriptor, entry, query, settings)
+          );
+        } catch (error) {
+          const msg = error.message;
+          failedTypes.push({ uid: descriptor.uid, message: msg });
+          strapi.log.warn(
+            `[${PLUGIN_ID}] search failed for ${descriptor.uid}: ${msg}`
+          );
+          return [];
+        }
+      }
+    );
+    const allHits = perType.flat();
+    const ranked = service(strapi, "ranking").sort(allHits).slice(0, settings.maxResults);
+    const total = ranked.length;
+    const pageCount = Math.ceil(total / safePageSize) || 0;
+    const safePage = Math.min(
+      Math.max(Math.floor(Number(page)) || 1, 1),
+      pageCount || 1
+    );
+    const start = (safePage - 1) * safePageSize;
+    const results = ranked.slice(start, start + safePageSize);
+    const groups = candidates.map((descriptor) => ({
+      uid: descriptor.uid,
+      label: descriptor.displayName,
+      kind: descriptor.kind,
+      count: ranked.filter((hit) => hit.contentTypeUid === descriptor.uid).length,
+      truncated: truncatedTypes.includes(descriptor.uid)
+    })).filter((group) => group.count > 0).sort((a, b) => b.count - a.count);
+    return {
+      query,
+      results,
+      groups,
+      pagination: { page: safePage, pageSize: safePageSize, total, pageCount },
+      meta: {
+        searchedTypes: candidates.length,
+        truncatedTypes,
+        failedTypes,
+        minChars: settings.minChars,
+        capped: allHits.length > settings.maxResults || total >= settings.maxResults || truncatedTypes.length > 0
+      }
+    };
+  }
+});
+
+// server/services/settings.ts
+var STORE_KEY = "settings";
+var ALLOWED_KEYS = Object.keys(defaults);
+var getStore = (strapi) => strapi.store({ type: "plugin", name: PLUGIN_ID });
+var pickAllowed = (source) => {
+  if (!isPlainObject(source)) return {};
+  return Object.entries(source).reduce((acc, [key, value]) => {
+    if (ALLOWED_KEYS.includes(key) && value !== void 0) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+};
+var settings_default2 = ({ strapi }) => ({
+  /**
+   * Resolution order: values saved from the Settings page, then `config/plugins.js`,
+   * then the built-in defaults. Every key always resolves to something usable.
+   */
+  async get() {
+    const fromFile = pickAllowed(strapi.config.get(`plugin::${PLUGIN_ID}`, {}));
+    const fromStore = pickAllowed(
+      await getStore(strapi).get({ key: STORE_KEY })
+    );
+    return { ...defaults, ...fromFile, ...fromStore };
+  },
+  async set(patch = {}) {
+    if (!isPlainObject(patch)) {
+      throw new Error("[global-search] settings payload must be an object");
+    }
+    const sanitized = pickAllowed(patch);
+    validator(sanitized);
+    const current = pickAllowed(await getStore(strapi).get({ key: STORE_KEY }));
+    const next = { ...current, ...sanitized };
+    await getStore(strapi).set({ key: STORE_KEY, value: next });
+    strapi.plugin(PLUGIN_ID).service("schema").clearCache();
+    return this.get();
+  },
+  async reset() {
+    await getStore(strapi).set({ key: STORE_KEY, value: {} });
+    strapi.plugin(PLUGIN_ID).service("schema").clearCache();
+    return this.get();
+  },
+  defaults
+});
+
+// server/services/index.ts
+var services_default = {
+  schema: schema_default2,
+  query: query_default,
+  ranking: ranking_default,
+  permissions: permissions_default,
+  settings: settings_default2,
+  search: search_default2
+};
+
+// server/index.ts
+var index_default = {
+  register: register_default,
+  bootstrap: bootstrap_default,
+  config: config_default,
+  controllers: controllers_default,
+  routes: routes_default,
+  services: services_default
+};
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map