@crowi/plugin-search-opensearch 0.1.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,805 @@
+// src/index.ts
+import { z } from "zod/v3";
+
+// src/driver.ts
+import { Client } from "@opensearch-project/opensearch";
+
+// src/parse-query.ts
+var normalize = (query) => {
+  return query.trim().replace(/\s+/g, " ");
+};
+var splitKeywordsAndPhrases = (query) => {
+  const phraseRegExp = /(-?"[^"]*")/g;
+  const keywords = query.replace(phraseRegExp, "").split(/\s+/g).filter(Boolean);
+  const phrases = (query.match(phraseRegExp) || []).map(normalize);
+  return { keywords, phrases };
+};
+var splitPositiveAndNegative = (queries) => {
+  const positive = [];
+  const negative = [];
+  for (const query of queries) {
+    const isNegative = query.startsWith("-");
+    const target = isNegative ? negative : positive;
+    const newQuery = isNegative ? query.substring(1) : query;
+    if (newQuery) {
+      target.push(newQuery);
+    }
+  }
+  return { positive, negative };
+};
+var unquote = (query) => {
+  return query.slice(1, -1);
+};
+var parseQuery = (query) => {
+  const { keywords, phrases } = splitKeywordsAndPhrases(normalize(query));
+  const { positive: positiveKeywords, negative: negativeKeywords } = splitPositiveAndNegative(keywords);
+  const { positive: positivePhrases, negative: negativePhrases } = splitPositiveAndNegative(phrases);
+  return {
+    keywords: {
+      positive: positiveKeywords,
+      negative: negativeKeywords
+    },
+    phrases: {
+      positive: positivePhrases.map(unquote).filter(Boolean),
+      negative: negativePhrases.map(unquote).filter(Boolean)
+    }
+  };
+};
+
+// src/query-builder.ts
+var GRANT_PUBLIC = 1;
+var defaultKeywordQueryFields = ["path.ja^2", "body.ja", "path.en^1.2", "body.en"];
+var defaultPhraseQueryFields = ["path.raw^2", "body"];
+var portalQuery = { regexp: { "path.raw": ".*/" } };
+var userPathQuery = { prefix: { "path.raw": "/user/" } };
+var emptyBuckets = () => ({ must: [], filter: [], should: [], must_not: [] });
+var appendKeywords = (buckets, keywords, operator, kind) => {
+  if (keywords.length === 0) return;
+  buckets[kind].push({
+    multi_match: {
+      query: keywords.join(" "),
+      fields: defaultKeywordQueryFields,
+      operator
+    }
+  });
+};
+var appendPhrases = (buckets, phrases, operator, kind) => {
+  for (const phrase of phrases) {
+    buckets[kind].push({
+      multi_match: {
+        type: "phrase",
+        query: phrase,
+        fields: defaultPhraseQueryFields,
+        operator
+      }
+    });
+  }
+};
+var appendTypeFilter = (buckets, type) => {
+  switch (type) {
+    case "portal":
+      buckets.must_not.push(userPathQuery);
+      buckets.filter.push(portalQuery);
+      return;
+    case "public":
+      buckets.must_not.push(userPathQuery);
+      buckets.must_not.push(portalQuery);
+      return;
+    case "user":
+      buckets.filter.push(userPathQuery);
+      return;
+  }
+};
+var appendPathPrefix = (buckets, pathPrefix) => {
+  const trimmed = pathPrefix.endsWith("/") ? pathPrefix.slice(0, -1) : pathPrefix;
+  buckets.filter.push({
+    wildcard: {
+      "path.raw": `${trimmed}/*`
+    }
+  });
+};
+var appendGrantFilter = (buckets, viewer) => {
+  if (!viewer) {
+    buckets.filter.push({ match: { grant: GRANT_PUBLIC } });
+    return;
+  }
+  if (viewer.isAdmin) {
+    return;
+  }
+  buckets.filter.push({
+    bool: {
+      should: [{ term: { grant: GRANT_PUBLIC } }, { term: { username: viewer.username } }, { term: { granted_users: viewer.id } }],
+      minimum_should_match: 1
+    }
+  });
+};
+function buildSearchBody(params) {
+  const { parsed, pathPrefix, viewer, grants, functionScore, from, size } = params;
+  const buckets = emptyBuckets();
+  appendKeywords(buckets, parsed.keywords.positive, "and", "must");
+  appendKeywords(buckets, parsed.keywords.negative, "or", "must_not");
+  appendPhrases(buckets, parsed.phrases.positive, "and", "must");
+  appendPhrases(buckets, parsed.phrases.negative, "or", "must_not");
+  if (pathPrefix) {
+    appendPathPrefix(buckets, pathPrefix);
+  }
+  if (grants?.types && grants.types.length > 0) {
+    if (grants.types.length === 1) {
+      appendTypeFilter(buckets, grants.types[0]);
+    } else {
+      const typeShoulds = grants.types.map((t) => {
+        const inner = emptyBuckets();
+        appendTypeFilter(inner, t);
+        return { bool: pruneBool(inner) };
+      });
+      buckets.filter.push({
+        bool: { should: typeShoulds, minimum_should_match: 1 }
+      });
+    }
+  }
+  appendGrantFilter(buckets, viewer);
+  const baseQuery = { bool: pruneBool(buckets) };
+  const query = functionScore ? {
+    function_score: {
+      query: baseQuery,
+      field_value_factor: functionScore.fieldValueFactor,
+      boost_mode: functionScore.boostMode
+    }
+  } : baseQuery;
+  return {
+    from,
+    size,
+    sort: [{ _score: "desc" }],
+    highlight: {
+      pre_tags: ["<mark>"],
+      post_tags: ["</mark>"],
+      fields: {
+        "path.ja": {},
+        "body.ja": {},
+        body: {}
+      }
+    },
+    query,
+    _source: ["path", "bookmark_count", "username", "grant"]
+  };
+}
+function pruneBool(buckets) {
+  const out = {};
+  if (buckets.must.length > 0) out.must = buckets.must;
+  if (buckets.filter.length > 0) out.filter = buckets.filter;
+  if (buckets.should.length > 0) out.should = buckets.should;
+  if (buckets.must_not.length > 0) out.must_not = buckets.must_not;
+  return out;
+}
+
+// src/mappings/default.json
+var default_default = {
+  settings: {
+    analysis: {
+      filter: {
+        english_stop: {
+          type: "stop",
+          stopwords: "_english_"
+        },
+        english_stemmer: {
+          type: "stemmer",
+          language: "english"
+        },
+        english_possessive_stemmer: {
+          type: "stemmer",
+          language: "possessive_english"
+        }
+      },
+      tokenizer: {
+        ngram_tokenizer: {
+          type: "ngram",
+          min_gram: 2,
+          max_gram: 3,
+          token_chars: ["letter", "digit"]
+        }
+      },
+      analyzer: {
+        english: {
+          tokenizer: "ngram_tokenizer",
+          filter: ["english_possessive_stemmer", "lowercase", "english_stop", "english_stemmer"]
+        }
+      }
+    }
+  },
+  mappings: {
+    properties: {
+      path: {
+        type: "text",
+        fields: {
+          raw: {
+            type: "text",
+            analyzer: "keyword"
+          },
+          en: {
+            type: "text",
+            analyzer: "english"
+          }
+        }
+      },
+      body: {
+        type: "text",
+        fields: {
+          en: {
+            type: "text",
+            analyzer: "english"
+          }
+        }
+      },
+      username: {
+        type: "keyword"
+      },
+      grant: {
+        type: "integer"
+      },
+      granted_users: {
+        type: "keyword"
+      },
+      comment_count: {
+        type: "integer"
+      },
+      bookmark_count: {
+        type: "integer"
+      },
+      like_count: {
+        type: "integer"
+      },
+      created_at: {
+        type: "date",
+        format: "strict_date_optional_time"
+      },
+      updated_at: {
+        type: "date",
+        format: "strict_date_optional_time"
+      }
+    }
+  }
+};
+
+// src/mappings/kuromoji.json
+var kuromoji_default = {
+  mappings: {
+    properties: {
+      path: {
+        fields: {
+          ja: {
+            type: "text",
+            analyzer: "kuromoji"
+          }
+        }
+      },
+      body: {
+        fields: {
+          ja: {
+            type: "text",
+            analyzer: "kuromoji"
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/mappings/sudachi.json
+var sudachi_default = {
+  settings: {
+    analysis: {
+      tokenizer: {
+        sudachi_tokenizer: {
+          type: "sudachi_tokenizer",
+          mode: "search"
+        }
+      },
+      analyzer: {
+        sudachi_analyzer: {
+          filter: [],
+          tokenizer: "sudachi_tokenizer",
+          type: "custom"
+        }
+      }
+    }
+  },
+  mappings: {
+    properties: {
+      path: {
+        fields: {
+          ja: {
+            type: "text",
+            analyzer: "sudachi_analyzer"
+          }
+        }
+      },
+      body: {
+        fields: {
+          ja: {
+            type: "text",
+            analyzer: "sudachi_analyzer"
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/driver.ts
+function applyConfig(config) {
+  if (!config.url) {
+    return {
+      client: null,
+      node: "",
+      baseIndexName: config.indexName,
+      aliasName: `${config.indexName}-current`,
+      analyzer: config.analyzer,
+      requestTimeout: config.requestTimeout
+    };
+  }
+  const { node, indexName } = parseUri(config.url);
+  const clientOpts = {
+    node,
+    requestTimeout: config.requestTimeout
+  };
+  return {
+    client: new Client(clientOpts),
+    node,
+    baseIndexName: indexName,
+    aliasName: `${indexName}-current`,
+    analyzer: config.analyzer,
+    requestTimeout: config.requestTimeout
+  };
+}
+function applyConfigInPlace(target, config) {
+  const oldClient = target.client;
+  Object.assign(target, applyConfig(config));
+  return { oldClient };
+}
+var USER_COUNT_TTL_MS = 5 * 60 * 1e3;
+function createOpenSearchDriver(state2, deps = {}) {
+  const log = deps.log;
+  let userCountCache = null;
+  const getCachedUserCount = async () => {
+    if (!deps.countUsers) return null;
+    const now = Date.now();
+    if (userCountCache && now - userCountCache.at < USER_COUNT_TTL_MS) {
+      return userCountCache.value;
+    }
+    const value = await deps.countUsers();
+    userCountCache = { value, at: now };
+    return value;
+  };
+  const driver = {
+    // Getters off the state ref: `reconfigure` makes these mutable, so
+    // they must always reflect the *current* state, not a boot-time
+    // literal. Tests read `driver.client` to install fakes — since the
+    // getter returns the same object reference, mutating its methods
+    // still works.
+    get aliasName() {
+      return state2.aliasName;
+    },
+    get node() {
+      return state2.node;
+    },
+    get baseIndexName() {
+      return state2.baseIndexName;
+    },
+    get client() {
+      return requireClient(state2.client);
+    },
+    async index(doc) {
+      const { client, aliasName } = snapshot(state2);
+      const source = docToEsSource(doc);
+      await client.index({
+        index: aliasName,
+        id: doc.id,
+        body: source
+      });
+    },
+    async remove(id) {
+      const { client, aliasName } = snapshot(state2);
+      try {
+        await client.delete({ index: aliasName, id });
+      } catch (err) {
+        if (isNotFoundError(err)) return;
+        throw err;
+      }
+    },
+    async query(q) {
+      const { client, aliasName } = snapshot(state2);
+      const page = q.page && q.page > 0 ? q.page : 1;
+      const limit = clampLimit(q.limit);
+      const from = (page - 1) * limit;
+      let functionScore;
+      const userCount = await getCachedUserCount();
+      if (userCount !== null) {
+        const factor = 1e4 / (userCount || 1);
+        functionScore = {
+          fieldValueFactor: { field: "bookmark_count", modifier: "log1p", factor, missing: 0 },
+          boostMode: "sum"
+        };
+      }
+      const body = buildSearchBody({
+        parsed: parseQuery(q.q),
+        pathPrefix: q.pathPrefix,
+        viewer: q.viewer,
+        grants: q.grants,
+        functionScore,
+        from,
+        size: limit
+      });
+      const response = await client.search({
+        index: aliasName,
+        body
+      });
+      const payload = response.body ?? {};
+      const totalRaw = payload.hits?.total;
+      const total = typeof totalRaw === "number" ? totalRaw : totalRaw?.value ?? 0;
+      const rawHits = payload.hits?.hits ?? [];
+      const hits = rawHits.map((h) => {
+        const source = h._source ?? {};
+        const snippet = pickSnippet(h.highlight);
+        return {
+          id: String(h._id),
+          path: source.path ?? "",
+          score: typeof h._score === "number" ? h._score : void 0,
+          ...snippet ? { snippet } : {}
+        };
+      });
+      return { total, hits };
+    },
+    async rebuild() {
+      const { client, aliasName, baseIndexName, analyzer } = snapshot(state2);
+      if (!deps.iteratePages || !deps.countAllPages || !deps.getBookmarkCountsBulk) {
+        throw new Error("@crowi/plugin-search-opensearch: rebuild() requires iteratePages / countAllPages / getBookmarkCountsBulk deps.");
+      }
+      const newIndexName = createTimestampedIndexName(baseIndexName);
+      log?.info("rebuild: creating index %s", newIndexName);
+      const mapping = loadMapping(analyzer);
+      await client.indices.create({ index: newIndexName, body: mapping });
+      log?.info("rebuild: prefetching bookmark counts");
+      const bookmarkCounts = await deps.getBookmarkCountsBulk();
+      log?.info("rebuild: indexing all pages");
+      await indexAllPages({
+        client,
+        indexTarget: newIndexName,
+        iteratePages: deps.iteratePages,
+        countAllPages: deps.countAllPages,
+        bookmarkCounts,
+        log
+      });
+      log?.info("rebuild: switching alias %s -> %s", aliasName, newIndexName);
+      await switchAlias(client, aliasName, newIndexName);
+      log?.info("rebuild: cleaning up old indices");
+      await deleteOldIndices(client, baseIndexName, newIndexName);
+    }
+  };
+  return driver;
+}
+var SEARCH_NOT_CONFIGURED = "@crowi/plugin-search-opensearch: Search not configured (OpenSearch url is empty).";
+function requireClient(client) {
+  if (!client) {
+    throw new Error(SEARCH_NOT_CONFIGURED);
+  }
+  return client;
+}
+function snapshot(state2) {
+  return {
+    client: requireClient(state2.client),
+    aliasName: state2.aliasName,
+    baseIndexName: state2.baseIndexName,
+    analyzer: state2.analyzer
+  };
+}
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+function clampLimit(limit) {
+  if (!limit || limit <= 0) return DEFAULT_LIMIT;
+  return Math.min(limit, MAX_LIMIT);
+}
+function parseUri(uri) {
+  if (!uri.startsWith("http")) {
+    throw new Error("URL for OpenSearch should starts with http/https");
+  }
+  const osUrl = new URL(uri);
+  const auth = osUrl.username && osUrl.password ? `${osUrl.username}:${osUrl.password}@` : "";
+  const node = `${osUrl.protocol}//${auth}${osUrl.host}`;
+  const indexName = osUrl.pathname && osUrl.pathname !== "/" ? osUrl.pathname.substring(1) : "crowi";
+  return { node, indexName };
+}
+function createTimestampedIndexName(base) {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  const ts = `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}${pad(d.getUTCMilliseconds(), 3)}`;
+  const rnd = Math.random().toString(36).slice(2, 6).padEnd(4, "0");
+  return `${base}-${ts}-${rnd}`;
+}
+var TS_INDEX_RE = /^.+-\d{17}-[a-z0-9]{4}$/;
+function loadMapping(analyzer) {
+  const base = default_default;
+  if (analyzer === "default") return base;
+  const overlay = analyzer === "kuromoji" ? kuromoji_default : sudachi_default;
+  return deepMergeMappings(base, overlay);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMergeMappings(a, b) {
+  const out = { ...a };
+  for (const key of Object.keys(b)) {
+    const av = a[key];
+    const bv = b[key];
+    if (isPlainObject(av) && isPlainObject(bv)) {
+      out[key] = deepMergeMappings(av, bv);
+    } else {
+      out[key] = bv;
+    }
+  }
+  return out;
+}
+async function indexAllPages(ctx) {
+  const allPageCount = await ctx.countAllPages();
+  let operations = [];
+  let total = 0;
+  let skipped = 0;
+  const flush = async () => {
+    if (operations.length === 0) return;
+    try {
+      const response = await ctx.client.bulk({
+        body: operations,
+        timeout: "1d"
+      });
+      const payload = response.body ?? {};
+      if (payload.errors) {
+        ctx.log?.warn("rebuild: bulk had item-level errors (took=%dms)", payload.took);
+      }
+    } catch (err) {
+      ctx.log?.error("rebuild: bulk failed: %o", err);
+    }
+    operations = [];
+  };
+  await ctx.iteratePages(async (doc) => {
+    if (!doc.creator || !doc.revision || !shouldIndex(doc)) {
+      skipped++;
+      return;
+    }
+    total++;
+    const id = typeof doc._id === "string" ? doc._id : doc._id.toString();
+    const bookmarkCount = ctx.bookmarkCounts.get(id) ?? 0;
+    const source = pageStreamDocToEsSource(doc, bookmarkCount);
+    operations.push({ index: { _index: ctx.indexTarget, _id: id } });
+    operations.push(source);
+    if (operations.length >= 4e3) {
+      await flush();
+    }
+  });
+  await flush();
+  ctx.log?.info("rebuild: indexed total=%d skipped=%d (allPageCount=%d)", total, skipped, allPageCount);
+}
+function shouldIndex(doc) {
+  if (doc.redirectTo !== null && doc.redirectTo !== void 0) return false;
+  if (doc.status === "deleted") return false;
+  if (doc.status === "draft") return false;
+  return true;
+}
+async function switchAlias(client, aliasName, newIndex) {
+  const aliasInfo = await getCurrentAliasInfo(client, aliasName);
+  const actions = [{ add: { index: newIndex, alias: aliasName } }];
+  if (aliasInfo) {
+    actions.push({ remove: { index: aliasInfo.index, alias: aliasName } });
+  }
+  await client.indices.updateAliases({ body: { actions } });
+}
+async function getCurrentAliasInfo(client, aliasName) {
+  try {
+    const exists = await client.indices.existsAlias({ name: aliasName });
+    if (!exists.body) return null;
+  } catch {
+    return null;
+  }
+  const aliases = await client.cat.aliases({ name: aliasName, format: "json" });
+  const list = aliases.body ?? [];
+  return list.length > 0 ? { alias: list[0].alias, index: list[0].index } : null;
+}
+async function deleteOldIndices(client, baseIndexName, keepIndexName) {
+  const indices = await client.cat.indices({ index: `${baseIndexName}-*`, format: "json" });
+  const list = indices.body ?? [];
+  const toDelete = list.map((i) => i.index).filter((name) => name.startsWith(`${baseIndexName}-`) && name !== keepIndexName && TS_INDEX_RE.test(name));
+  if (toDelete.length === 0) return;
+  await client.indices.delete({ index: toDelete });
+}
+function isNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.statusCode === 404 || e.meta?.statusCode === 404;
+}
+function docToEsSource(doc) {
+  const meta = doc.meta ?? {};
+  const source = {
+    path: doc.path,
+    body: doc.body
+  };
+  const username = readString(meta.username);
+  if (username !== void 0) source.username = username;
+  const grant = readNumber(meta.grant);
+  if (grant !== void 0) source.grant = grant;
+  const grantedUsers = readStringArray(meta.granted_users ?? meta.grantedUsers);
+  if (grantedUsers !== void 0) source.granted_users = grantedUsers;
+  const commentCount = readNumber(meta.comment_count ?? meta.commentCount);
+  if (commentCount !== void 0) source.comment_count = commentCount;
+  const bookmarkCount = readNumber(meta.bookmark_count ?? meta.bookmarkCount);
+  if (bookmarkCount !== void 0) source.bookmark_count = bookmarkCount;
+  const likeCount = readNumber(meta.like_count ?? meta.likeCount);
+  if (likeCount !== void 0) source.like_count = likeCount;
+  const createdAt = readDateLike(meta.created_at ?? meta.createdAt);
+  if (createdAt !== void 0) source.created_at = createdAt;
+  const updatedAt = readDateLike(meta.updated_at ?? meta.updatedAt);
+  if (updatedAt !== void 0) source.updated_at = updatedAt;
+  return source;
+}
+function pageStreamDocToEsSource(doc, bookmarkCount) {
+  const grantedUsers = (doc.grantedUsers ?? []).map((u) => typeof u === "string" ? u : u.toString());
+  const searchable = {
+    id: typeof doc._id === "string" ? doc._id : doc._id.toString(),
+    path: doc.path,
+    body: doc.revision?.body ?? "",
+    meta: {
+      username: doc.creator?.username,
+      grant: doc.grant,
+      granted_users: grantedUsers,
+      comment_count: doc.commentCount ?? 0,
+      bookmark_count: bookmarkCount,
+      like_count: doc.liker?.length ?? 0,
+      created_at: doc.createdAt,
+      updated_at: doc.updatedAt
+    }
+  };
+  return docToEsSource(searchable);
+}
+function pickSnippet(highlight) {
+  if (!highlight) return void 0;
+  for (const field of ["body.ja", "body", "path.ja", "body.en", "path.en"]) {
+    const fragments = highlight[field];
+    if (fragments && fragments.length > 0) return fragments[0];
+  }
+  return void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const v of value) {
+    if (typeof v === "string") out.push(v);
+    else if (v && typeof v === "object" && typeof v.toString === "function") {
+      out.push(v.toString());
+    }
+  }
+  return out;
+}
+function readDateLike(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string") return value;
+  return void 0;
+}
+
+// src/index.ts
+var OpenSearchConfigSchema = z.object({
+  /**
+   * `https://[user:pass@]host[:port][/indexName]`. Empty string keeps
+   * the driver registered but disabled — `query()` will throw a
+   * helpful error and `index()` becomes a no-op.
+   *
+   * Marked `@sensitive` because the URL embeds the cluster password
+   * (Bonsai-style `https://USER:PASS@HOST/INDEX`); we don't want
+   * Mongo to keep it in plaintext.
+   */
+  url: z.string().describe("@sensitive OpenSearch endpoint (https://USER:PASS@HOST/INDEX format).").default(""),
+  /**
+   * Base index name. Used as the `indexName` if not provided in the
+   * URL path. The runtime alias `${indexName}-current` is what the
+   * driver actually targets for read / write.
+   */
+  indexName: z.string().default("crowi"),
+  requestTimeout: z.number().int().positive().default(5e3),
+  /**
+   * Mapping flavour. Cluster requirements:
+   *   - `default`: no extra OpenSearch plugin.
+   *   - `kuromoji`: `analysis-kuromoji` plugin (Apache 2.0, a
+   *     separate distribution from OpenSearch core — install via
+   *     `bin/opensearch-plugin install analysis-kuromoji`).
+   *   - `sudachi`: `analysis-sudachi` (OpenSearch-compatible fork
+   *     from WorksApplications) + dictionary; operators must build
+   *     a derived image. Picking this without the plugin makes
+   *     `rebuild()` fail.
+   */
+  analyzer: z.enum(["default", "kuromoji", "sudachi"]).describe("default / kuromoji (analysis-kuromoji plugin) / sudachi (analysis-sudachi plugin + dictionary, custom image required)").default("default")
+}).strict();
+var PLUGIN_NAME = "@crowi/plugin-search-opensearch";
+var state = null;
+function toDriverConfig(config) {
+  return {
+    url: config.url,
+    indexName: config.indexName,
+    requestTimeout: config.requestTimeout,
+    analyzer: config.analyzer
+  };
+}
+var plugin = {
+  name: PLUGIN_NAME,
+  version: "0.1.0-dev",
+  configSchema: OpenSearchConfigSchema,
+  adminPlacement: {
+    label: "OpenSearch",
+    icon: "search"
+    // section omitted: derived from registerSearch -> 'shared' fallback
+  },
+  registerSearch: (registry, ctx) => {
+    const config = ctx.config();
+    if (!config.url) {
+      ctx.log.warn("url is empty; the opensearch search driver is disabled until configured.");
+      return;
+    }
+    state = applyConfig(toDriverConfig(config));
+    const driver = buildDriver(state, ctx);
+    registry.register("opensearch", driver);
+    ctx.log.debug("registered opensearch search driver (node=%s, indexName=%s, analyzer=%s)", driver.node, driver.baseIndexName, config.analyzer);
+  },
+  reconfigure: (ctx) => {
+    if (!state) {
+      ctx.log.warn("reconfigure: driver was not registered at boot (url was empty); a server restart is required to enable OpenSearch search.");
+      return;
+    }
+    const config = ctx.config();
+    if (!config.url) {
+      ctx.log.warn('reconfigure: url cleared; search requests will fail with a "Search not configured" error until a url is set.');
+    }
+    const { oldClient } = applyConfigInPlace(state, toDriverConfig(config));
+    if (oldClient) {
+      void oldClient.close().catch((err) => {
+        ctx.log.warn("reconfigure: closing the previous OpenSearch client failed: %o", err);
+      });
+    }
+    ctx.log.debug("reconfigured opensearch search driver (node=%s, index=%s, analyzer=%s)", state.node || "<unset>", state.baseIndexName, config.analyzer);
+  }
+};
+var index_default = plugin;
+function buildDriver(driverState, ctx) {
+  const Page = ctx.model("Page");
+  const Bookmark = ctx.model("Bookmark");
+  const User = ctx.model("User");
+  return createOpenSearchDriver(driverState, {
+    log: ctx.log,
+    iteratePages: async (handler) => {
+      const cursor = Page.getStreamOfFindAll({ publicOnly: false });
+      await cursor.eachAsync(handler);
+    },
+    countAllPages: () => Page.allPageCount(),
+    getBookmarkCountsBulk: async () => {
+      const rows = await Bookmark.aggregate([{ $group: { _id: "$page", n: { $sum: 1 } } }]);
+      const map = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const key = typeof row._id === "string" ? row._id : row._id.toString();
+        map.set(key, row.n);
+      }
+      return map;
+    },
+    countUsers: () => User.countDocuments({}).exec()
+  });
+}
+export {
+  OpenSearchConfigSchema,
+  applyConfig,
+  applyConfigInPlace,
+  buildSearchBody,
+  createOpenSearchDriver,
+  index_default as default,
+  parseQuery
+};
+//# sourceMappingURL=index.mjs.map