@dalencatt/strapi-plugin-fuzzy-search-private 0.0.0-development

package/dist/server/index.js

@@ -0,0 +1,695 @@
+"use strict";
+const yup = require("yup");
+const utils = require("@strapi/utils");
+const fuzzysort = require("fuzzysort");
+const transliteration = require("transliteration");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const yup__namespace = /* @__PURE__ */ _interopNamespace(yup);
+const fuzzysort__default = /* @__PURE__ */ _interopDefault(fuzzysort);
+const bootstrap = () => {
+};
+const pluginConfigSchema = yup__namespace.object({
+  contentTypes: yup__namespace.array().of(
+    yup__namespace.object({
+      uid: yup__namespace.string().required(),
+      modelName: yup__namespace.string().required(),
+      transliterate: yup__namespace.boolean(),
+      fuzzysortOptions: yup__namespace.object({
+        threshold: yup__namespace.number(),
+        limit: yup__namespace.number(),
+        keys: yup__namespace.array().of(
+          yup__namespace.object({
+            name: yup__namespace.string().required(),
+            weight: yup__namespace.number()
+          })
+        )
+      }).required()
+    })
+  )
+}).noUnknown();
+const config = {
+  default() {
+    return {
+      contentTypes: {}
+    };
+  },
+  async validator(config2) {
+    await pluginConfigSchema.validate(config2);
+  }
+};
+const paginationSchema = yup.object({
+  pageSize: yup.string().matches(/^\d+$/, "pageSize must be an integer"),
+  page: yup.string().matches(/^\d+$/, "page must be an integer"),
+  withCount: yup.string().oneOf(
+    ["true", "false"],
+    "withCount must either be 'true' or 'false'"
+  )
+});
+yup.string().required();
+const querySchema = yup.object({
+  query: yup.string().required(),
+  locale: yup.string(),
+  filters: yup.object({
+    contentTypes: yup.string()
+  })
+});
+const { ValidationError } = utils.errors;
+const validateFilteredContentTypes = (configModels, filterModel) => {
+  if (!configModels.has(filterModel))
+    throw new Error(
+      `'${filterModel}' was found in contentTypes filter query, however this model is not configured in the fuzzy-search config`
+    );
+};
+const validatePaginationQueryParams = async (configModels, pagination) => {
+  const paginatedEntries = Object.entries(pagination);
+  for (const [pluralName, paginationValues] of paginatedEntries) {
+    if (!configModels.has(pluralName)) {
+      throw new Error(
+        `Pagination queries for model '${pluralName}' were found, however this model is not configured in the fuzzy-search config`
+      );
+    }
+    await paginationSchema.validate(paginationValues);
+  }
+};
+const validateNestedQueryParams = (configModels, nestedParams) => {
+  const filterKeys = Object.keys(nestedParams);
+  filterKeys.forEach((key) => {
+    if (key !== "contentTypes" && !configModels.has(key)) {
+      throw new Error(
+        `Query params for model '${key}' were found, however this model is not configured in the fuzzy-search config`
+      );
+    }
+  });
+};
+const validateQueryParams = async (query, contentTypes, pagination, populate, filteredContentTypes) => {
+  const configModels = new Set(
+    contentTypes.map((contentType) => contentType.info.pluralName)
+  );
+  await querySchema.validate(query);
+  if (pagination) await validatePaginationQueryParams(configModels, pagination);
+  if (query.filters) validateNestedQueryParams(configModels, query.filters);
+  if (populate) validateNestedQueryParams(configModels, populate);
+  if (filteredContentTypes)
+    filteredContentTypes.forEach(
+      (model) => validateFilteredContentTypes(configModels, model)
+    );
+};
+const validateQuery = async (contentType, locale) => {
+  if (contentType.kind !== "collectionType")
+    throw new ValidationError(
+      `Content type: '${contentType.modelName}' is not a collectionType`
+    );
+  contentType.fuzzysortOptions.keys.forEach((key) => {
+    const attributeKeys = Object.keys(contentType.attributes);
+    if (!attributeKeys.includes(key.name))
+      throw new ValidationError(
+        `Key: '${key.name}' is not a valid field for model: '${contentType.modelName}`
+      );
+  });
+  if (!locale) return;
+  const isLocalizedContentType = await strapi.plugins.i18n.services["content-types"].isLocalizedContentType(
+    contentType
+  );
+  if (!isLocalizedContentType) {
+    throw new ValidationError(
+      `A query for the locale: '${locale}' was found, however model: '${contentType.modelName}' is not a localized content type. Enable localization for all content types if you want to query for localized entries via the locale parameter.`
+    );
+  }
+};
+const weightScores = (a, keys) => {
+  const weightedScores = keys.map((key, index2) => {
+    const weight = key.weight || 0;
+    return a[index2] ? +a[index2].score + weight : -9999;
+  });
+  return Math.max(...weightedScores);
+};
+const transformEntryKeysToString = (entries, keys) => entries.map(
+  (entry) => transformEntry(entry, keys, (value) => value?.toString())
+);
+const limitCharacters = (entries, characterLimit, keys) => entries.map(
+  (entry) => transformEntry(
+    entry,
+    keys,
+    (value) => value?.toString().slice(0, characterLimit)
+  )
+);
+const transformEntry = (entry, keys, transformFn) => {
+  const transformedEntry = { ...entry };
+  const entryKeys = Object.keys(transformedEntry);
+  entryKeys.forEach((key) => {
+    if (!keys.includes(key)) return;
+    transformedEntry[key] = transformFn(transformedEntry[key]);
+  });
+  return transformedEntry;
+};
+const buildResult = ({
+  entries,
+  fuzzysortOptions,
+  keys,
+  query
+}) => {
+  const transformedEntries = fuzzysortOptions.characterLimit ? limitCharacters(entries, fuzzysortOptions.characterLimit, keys) : transformEntryKeysToString(entries, keys);
+  return fuzzysort__default.default.go(query, transformedEntries, {
+    threshold: fuzzysortOptions.threshold,
+    limit: fuzzysortOptions.limit,
+    keys,
+    scoreFn: (a) => weightScores(a, fuzzysortOptions.keys)
+  });
+};
+const transliterateEntries = (entries) => entries.map((entry) => {
+  const entryKeys = Object.keys(entry);
+  entry.transliterations = {};
+  entryKeys.forEach((key) => {
+    if (!entry[key]) return;
+    entry.transliterations[key] = transliteration.transliterate(entry[key]);
+  });
+  return entry;
+});
+const buildTransliteratedResult = ({
+  entries,
+  fuzzysortOptions,
+  keys,
+  query,
+  result
+}) => {
+  const { keys: fuzzysortKeys, threshold, limit } = fuzzysortOptions;
+  const transliteratedEntries = transliterateEntries(entries);
+  const transliterationKeys = keys.map((key) => `transliterations.${key}`);
+  const transliteratedResult = fuzzysort__default.default.go(
+    query,
+    transliteratedEntries,
+    {
+      threshold,
+      limit,
+      keys: transliterationKeys,
+      scoreFn: (a) => weightScores(a, fuzzysortKeys)
+    }
+  );
+  entries.forEach((entry) => delete entry.transliterations);
+  if (!result.total) return transliteratedResult;
+  const newResults = [...result];
+  transliteratedResult.forEach((res) => {
+    const origIndex = newResults.findIndex(
+      (origRes) => origRes.obj.id === res.obj.id && origRes.score <= res.score
+    );
+    if (origIndex >= 0) newResults[origIndex] = res;
+  });
+  newResults.sort((a, b) => b.score - a.score);
+  return newResults;
+};
+async function getResult({
+  contentType,
+  query,
+  filters,
+  populate,
+  locale,
+  status
+}) {
+  const buildFilteredEntries = async () => {
+    await validateQuery(contentType, locale);
+    return await strapi.documents(contentType.uid).findMany({
+      ...filters && { filters },
+      ...locale && { locale },
+      ...populate && { populate },
+      status: status ?? "published"
+    });
+  };
+  const filteredEntries = await buildFilteredEntries();
+  const keys = contentType.fuzzysortOptions.keys.map((key) => key.name);
+  let result = buildResult({
+    entries: filteredEntries,
+    fuzzysortOptions: contentType.fuzzysortOptions,
+    keys,
+    query
+  });
+  if (contentType.transliterate) {
+    result = buildTransliteratedResult({
+      entries: filteredEntries,
+      fuzzysortOptions: contentType.fuzzysortOptions,
+      keys,
+      query,
+      result
+    });
+  }
+  return {
+    fuzzysortResults: result,
+    schema: contentType
+  };
+}
+const parsePaginationArgs = ({
+  page: pageQuery = "1",
+  pageSize: pageSizeQuery = "25",
+  withCount: withCountQuery = "true"
+}) => {
+  const page = parseInt(pageQuery, 10);
+  const pageSize = parseInt(pageSizeQuery, 10);
+  const withCount = withCountQuery === "true";
+  return { page, pageSize, withCount };
+};
+const paginateRestResults = async (pagination, pluralNames, resultsResponse) => {
+  const currentResult = { ...resultsResponse };
+  const paginatedResult = {};
+  const buildPaginatedResults = (pluralName) => {
+    const { page, pageSize, withCount } = parsePaginationArgs(
+      pagination[pluralName]
+    );
+    paginatedResult[pluralName] = {
+      data: [],
+      meta: { pagination: { page: 1, pageSize: 25 } }
+    };
+    const startIndex = pageSize * (page - 1);
+    const endIndex = startIndex + pageSize;
+    paginatedResult[pluralName].data = currentResult[pluralName].slice(
+      startIndex,
+      endIndex
+    );
+    const meta = {
+      pagination: {
+        page,
+        pageSize
+      }
+    };
+    if (withCount) {
+      const total = resultsResponse[pluralName].length;
+      meta.pagination.total = total;
+      meta.pagination.pageCount = Math.ceil(total / pageSize);
+    }
+    paginatedResult[pluralName].meta = meta;
+  };
+  pluralNames.forEach((pluralName) => {
+    if (!pagination[pluralName]) return;
+    buildPaginatedResults(pluralName);
+  });
+  return { ...resultsResponse, ...paginatedResult };
+};
+const paginateGraphQlResults = (results, { limit, start }) => {
+  const resultsCopy = [...results];
+  const data = resultsCopy.slice(start, start + limit);
+  const meta = {
+    start,
+    limit
+  };
+  return { data, meta };
+};
+const { sanitize } = strapi.contentAPI;
+const sanitizeOutput = (data, schema, auth) => sanitize.output(data, schema, { auth });
+const buildGraphqlResponse = async (searchResult, schema, auth, pagination) => {
+  const { service: getService } = strapi.plugin("graphql");
+  const { returnTypes } = getService("format");
+  const { toEntityResponseCollection } = returnTypes;
+  const results = await Promise.all(
+    searchResult.map(
+      async (fuzzyRes) => await sanitizeOutput(fuzzyRes.obj, schema, auth)
+    )
+  );
+  const { data: nodes, meta } = paginateGraphQlResults(results, pagination);
+  return toEntityResponseCollection(nodes, {
+    args: meta,
+    resourceUID: schema.uid
+  });
+};
+const buildRestResponse = async (searchResults, auth, pagination, queriedContentTypes) => {
+  const resultsResponse = {};
+  for (const res of searchResults) {
+    const sanitizeEntry = async (fuzzyRes) => {
+      return await sanitizeOutput(fuzzyRes.obj, res.schema, auth);
+    };
+    const buildSanitizedEntries = async () => res.fuzzysortResults.map(
+      async (fuzzyRes) => await sanitizeEntry(fuzzyRes)
+    );
+    resultsResponse[res.schema.info.pluralName] = await Promise.all(
+      await buildSanitizedEntries()
+    );
+  }
+  if (!pagination) return resultsResponse;
+  const modelNames = queriedContentTypes || Object.keys(pagination);
+  return await paginateRestResults(pagination, modelNames, resultsResponse);
+};
+const name = "strapi-plugin-fuzzy-search";
+const version = "0.0.0-development";
+const description = "Register a weighted fuzzy search endpoint for Strapi Headless CMS you can add your content types to in no time.";
+const strapi$1 = {
+  displayName: "Fuzzy Search",
+  name: "fuzzy-search",
+  description: "Register a weighted fuzzy search endpoint to your content types in no time.",
+  kind: "plugin"
+};
+const type = "commonjs";
+const exports$1 = {
+  "./package.json": "./package.json",
+  "./strapi-server": {
+    types: "./dist/server/src/index.d.ts",
+    source: "./server/src/index.ts",
+    "import": "./dist/server/index.mjs",
+    require: "./dist/server/index.js",
+    "default": "./dist/server/index.js"
+  }
+};
+const files = [
+  "dist"
+];
+const scripts = {
+  "semantic-release": "semantic-release",
+  build: "strapi-plugin build",
+  watch: "strapi-plugin watch",
+  "watch:link": "strapi-plugin watch:link",
+  verify: "strapi-plugin verify",
+  "test:ts:back": "run -T tsc -p server/tsconfig.json",
+  typecheck: "tsc --noEmit -p server/tsconfig.json",
+  test: "vitest",
+  "test:coverage": "vitest run --coverage",
+  "test:coverage:json": "vitest run --coverage.enabled --coverage.reporter=json-summary",
+  lint: "eslint .",
+  "prettier:check": "prettier --check ./server ./tests",
+  "prettier:write": "prettier --write ./server ./tests"
+};
+const publishConfig = {
+  registry: "https://registry.npmjs.org/",
+  tag: "latest"
+};
+const release = {
+  branches: [
+    "main",
+    {
+      name: "beta",
+      prerelease: true
+    }
+  ]
+};
+const dependencies = {
+  fuzzysort: "3.1.0",
+  transliteration: "2.3.5"
+};
+const peerDependencies = {
+  "@strapi/sdk-plugin": "^5.2.7",
+  "@strapi/strapi": "^5.1.1",
+  "@strapi/utils": "^5.1.1",
+  yup: "1.4.0"
+};
+const devDependencies = {
+  "@eslint/compat": "^1.2.2",
+  "@eslint/eslintrc": "^3.1.0",
+  "@eslint/js": "^9.13.0",
+  "@strapi/sdk-plugin": "^5.2.7",
+  "@strapi/strapi": "^5.1.1",
+  "@strapi/typescript-utils": "^5.1.1",
+  "@typescript-eslint/eslint-plugin": "8.12.1",
+  "@typescript-eslint/parser": "8.12.1",
+  "@vitest/coverage-v8": "2.1.4",
+  "all-contributors-cli": "^6.20.0",
+  eslint: "^9.13.0",
+  "eslint-config-prettier": "9.1.0",
+  "eslint-plugin-import": "2.31.0",
+  "eslint-plugin-prettier": "5.2.1",
+  "eslint-plugin-promise": "7.1.0",
+  globals: "^15.11.0",
+  prettier: "3.3.3",
+  "semantic-release": "^24.0.0",
+  typescript: "^5.6.3",
+  "typescript-eslint": "^8.12.1",
+  vitest: "2.1.4"
+};
+const author = "@DomDew (https://github.com/DomDew)";
+const maintainers = [
+  "@DomDew (https://github.com/DomDew)",
+  "@wfproductions (https://github.com/wfproductions)"
+];
+const engines = {
+  node: ">=18.x.x <=20.x.x",
+  npm: ">=6.0.0"
+};
+const license = "MIT";
+const repository = {
+  type: "git",
+  url: "https://github.com/DomDew/strapi-plugin-fuzzy-search.git"
+};
+const keywords = [
+  "strapi",
+  "fuzzysort",
+  "fuzzysearch",
+  "search"
+];
+const bugs = {
+  url: "https://github.com/DomDew/strapi-plugin-fuzzy-search/issues"
+};
+const homepage = "https://github.com/DomDew/strapi-plugin-fuzzy-search#readme";
+const packageJson = {
+  name,
+  version,
+  description,
+  strapi: strapi$1,
+  type,
+  exports: exports$1,
+  files,
+  scripts,
+  publishConfig,
+  release,
+  dependencies,
+  peerDependencies,
+  devDependencies,
+  author,
+  maintainers,
+  engines,
+  license,
+  repository,
+  keywords,
+  bugs,
+  homepage
+};
+const pluginId = packageJson.strapi.name;
+const settingsService = () => ({
+  get() {
+    return strapi.config.get(`plugin::${pluginId}`);
+  },
+  set(settings) {
+    return strapi.config.set(`plugin::${pluginId}`, settings);
+  },
+  build(settings) {
+    return {
+      ...settings,
+      contentTypes: settings.contentTypes.map((contentType) => ({
+        ...contentType,
+        ...strapi.contentTypes[contentType.uid]
+      }))
+    };
+  }
+});
+const { NotFoundError } = utils.errors;
+const searchController = () => ({
+  async search(ctx) {
+    const { contentTypes } = settingsService().get();
+    const {
+      query,
+      pagination,
+      filters: filtersQuery,
+      locale,
+      populate,
+      status: statusQuery
+    } = ctx.query;
+    const { auth } = ctx.state;
+    const queriedContentTypes = filtersQuery && filtersQuery.contentTypes ? filtersQuery.contentTypes?.split(",") : void 0;
+    try {
+      await validateQueryParams(
+        ctx.query,
+        contentTypes,
+        pagination,
+        populate,
+        queriedContentTypes
+      );
+    } catch (err) {
+      let message = "unknown error";
+      if (err instanceof Error) message = err.message;
+      return ctx.badRequest("Invalid query", message);
+    }
+    const queriedContentTypesSet = new Set(queriedContentTypes);
+    const filteredContentTypes = filtersQuery?.contentTypes ? [...contentTypes].filter(
+      (contentType) => queriedContentTypesSet.has(contentType.info.pluralName)
+    ) : contentTypes;
+    const results = await Promise.all(
+      filteredContentTypes.map(
+        async (contentType) => await getResult({
+          contentType,
+          query,
+          filters: filtersQuery?.[contentType.info.pluralName],
+          populate: populate?.[contentType.info.pluralName],
+          locale: filtersQuery?.[contentType.info.pluralName]?.locale || locale,
+          status: statusQuery?.[contentType.info.pluralName] || "published"
+        })
+      )
+    );
+    const response = await buildRestResponse(
+      results,
+      auth,
+      pagination,
+      queriedContentTypes
+    );
+    if (response) {
+      return response;
+    } else {
+      throw new NotFoundError();
+    }
+  }
+});
+const controllers = { searchController };
+const getResolversConfig = () => {
+  return {
+    "Query.search": {
+      auth: {
+        scope: "plugin::fuzzy-search.searchController.search"
+      }
+    }
+  };
+};
+const getCustomTypes = (strapi2, nexus) => {
+  const { service: getService } = strapi2.plugin("graphql");
+  const { naming } = getService("utils");
+  const { utils: utils2 } = getService("builders");
+  const { contentTypes } = settingsService().get();
+  const {
+    getEntityResponseCollectionName,
+    getFindQueryName,
+    getFiltersInputTypeName
+  } = naming;
+  const { transformArgs, getContentTypeArgs } = utils2;
+  const extendSearchType = (nexus2, model) => {
+    return nexus2.extendType({
+      type: "SearchResponse",
+      definition(t) {
+        t.field(getFindQueryName(model), {
+          type: getEntityResponseCollectionName(model),
+          args: getContentTypeArgs(model, { multiple: true }),
+          async resolve(parent, args, ctx, info) {
+            const { query, locale: parentLocaleQuery } = parent;
+            const {
+              pagination,
+              filters,
+              locale: contentTypeLocaleQuery,
+              status: contentTypeStatusQuery
+            } = args;
+            const locale = contentTypeLocaleQuery || parentLocaleQuery;
+            const {
+              start: transformedStart,
+              limit: transformedLimit,
+              filters: transformedFilters
+            } = transformArgs(
+              { pagination, filters },
+              {
+                contentType: model,
+                usePagination: true
+              }
+            );
+            const contentType = contentTypes.find(
+              (contentType2) => contentType2.modelName === model.modelName
+            );
+            if (!contentType) return;
+            const results = await getResult({
+              contentType,
+              query,
+              filters: transformedFilters,
+              populate: void 0,
+              locale,
+              status: contentTypeStatusQuery
+            });
+            const resultsResponse = await buildGraphqlResponse(
+              results.fuzzysortResults,
+              contentType,
+              ctx.state?.auth,
+              { start: transformedStart, limit: transformedLimit }
+            );
+            if (resultsResponse) return resultsResponse;
+            throw new Error(ctx.koaContext.response.message);
+          }
+        });
+      }
+    });
+  };
+  const searchResponseType = nexus.extendType({
+    type: "Query",
+    definition(t) {
+      t.field("search", {
+        type: "SearchResponse",
+        args: {
+          query: nexus.nonNull(
+            nexus.stringArg(
+              "The query string by which the models are searched"
+            )
+          ),
+          locale: nexus.stringArg("The locale by which to filter the models")
+        },
+        async resolve(_parent, args, ctx) {
+          const { query, locale } = args;
+          const { auth } = ctx.state;
+          return { query, locale, auth };
+        }
+      });
+    }
+  });
+  const returnTypes = [searchResponseType];
+  contentTypes.forEach((type2) => {
+    returnTypes.unshift(extendSearchType(nexus, type2));
+  });
+  return returnTypes;
+};
+const registerGraphlQLQuery = (strapi2) => {
+  const extension = ({ nexus }) => ({
+    types: getCustomTypes(strapi2, nexus),
+    resolversConfig: getResolversConfig()
+  });
+  strapi2.plugin("graphql").service("extension").use(extension);
+};
+const register = ({ strapi: strapi2 }) => {
+  const {
+    get: getSettings,
+    build: buildSettings,
+    set: setSettings
+  } = settingsService();
+  const settings = getSettings();
+  const normalizedSettings = buildSettings(settings);
+  setSettings(normalizedSettings);
+  if (strapi2.plugin("graphql")) {
+    strapi2.log.info("[fuzzy-search] graphql detected, registering queries");
+    registerGraphlQLQuery(strapi2);
+  }
+};
+const searchRoutes = [
+  {
+    method: "GET",
+    path: "/search",
+    handler: "searchController.search"
+  }
+];
+const routes = {
+  "content-api": {
+    type: "content-api",
+    routes: searchRoutes
+  }
+};
+const services = {
+  settingsService
+};
+const index = {
+  bootstrap,
+  register,
+  config,
+  controllers,
+  routes,
+  services
+};
+module.exports = index;