@mindful-web/marko-web-search 1.0.0

package/config/param.js

@@ -0,0 +1,69 @@
+const { isFunction: isFn } = require('@mindful-web/utils');
+
+class MarkoWebSearchQueryParam {
+  constructor({
+    name,
+    type,
+    defaultValue,
+    validator,
+    filter,
+    toInput,
+    fromInput,
+  } = {}) {
+    this.name = name;
+    this.type = type;
+    this.defaultValue = defaultValue;
+    this.validator = validator;
+    this.filter = filter;
+    this.toInput = toInput;
+    this.fromInput = fromInput;
+  }
+
+  toInputValue(value, $markoWebSearch) {
+    const { toInput, filter, validator } = this;
+    const defaultValue = this.getDefaultValue();
+
+    let input = isFn(toInput) ? toInput(value) : value;
+    if (input == null) input = defaultValue;
+    if (isFn(filter)) input = filter(input);
+    const isValid = isFn(validator) ? validator(input, $markoWebSearch) : true;
+    return isValid ? input : defaultValue;
+  }
+
+  toQueryValue(input, $markoWebSearch) {
+    const { fromInput, filter, validator } = this;
+    const defaultValue = this.getDefaultValue();
+
+    let v = input;
+    if (v == null) v = defaultValue;
+    if (isFn(filter)) v = filter(v);
+    const isValid = isFn(validator) ? validator(v, $markoWebSearch) : true;
+    if (!isValid) v = defaultValue;
+    if (this.isDefaultValue(v)) return null;
+    if (isFn(fromInput)) v = fromInput(v);
+    return v;
+  }
+
+  isDefaultValue(input) {
+    const defaultValue = this.getDefaultValue();
+    return this.areInputsEqual(input, defaultValue);
+  }
+
+  areInputsEqual(input1, input2) {
+    if (this.isArray()) {
+      return input1.sort().join('') === input2.sort().join('');
+    }
+    return input1 === input2;
+  }
+
+  getDefaultValue() {
+    const { defaultValue } = this;
+    return (isFn(defaultValue)) ? defaultValue() : defaultValue;
+  }
+
+  isArray() {
+    return this.type === Array;
+  }
+}
+
+module.exports = MarkoWebSearchQueryParam;

package/config/query-params.js

@@ -0,0 +1,101 @@
+const MarkoWebSearchQueryParam = require('./param');
+
+const { isArray } = Array;
+
+const unqArray = (array) => [...new Set(array)];
+
+const toArrayInput = (str, mapFunc) => {
+  if (!str) return undefined;
+  const trimmed = str.trim();
+  if (!trimmed) return undefined;
+  return unqArray(trimmed.split(',').map(mapFunc).filter((v) => v));
+};
+
+const fromArrayInput = (arr) => {
+  if (!isArray(arr) || !arr.length) return null;
+  return unqArray(arr.sort().filter((i) => i)).join(',');
+};
+
+const toIntArrayInput = (arr) => toArrayInput(arr, (v) => parseInt(v, 10));
+const toStringArrayInput = (arr) => toArrayInput(arr, (v) => v.trim());
+
+const sortFieldSet = new Set(['NAME', 'PUBLISHED', 'SCORE']);
+const sortOrderSet = new Set(['DESC', 'ASC']);
+
+class MarkoWebSearchQueryParamConfig {
+  constructor({
+    resultsPerPage = {},
+    contentTypeIds = [],
+    defaultSortField = 'PUBLISHED',
+  } = {}) {
+    this.params = new Map();
+
+    const contentTypeIdMap = contentTypeIds.reduce((m, id) => {
+      m.set(id, true);
+      return m;
+    }, new Map());
+
+    this
+      .add('limit', {
+        type: Number,
+        defaultValue: resultsPerPage.default,
+        validator: (v) => (v >= resultsPerPage.min && v <= resultsPerPage.max),
+        toInput: (v) => parseInt(v, 10),
+      })
+      .add('page', {
+        type: Number,
+        defaultValue: 1,
+        validator: (v, search) => {
+          if (v < 1) return false;
+          const limit = search.getInputValueFor('limit');
+          return ((v * limit) <= 10000);
+        },
+        toInput: (v) => parseInt(v, 10),
+      })
+      .add('searchQuery', {
+        type: String,
+        defaultValue: '',
+      })
+      .add('contentTypes', {
+        type: Array,
+        defaultValue: () => contentTypeIds.slice(),
+        filter: (types) => types.filter((type) => contentTypeIdMap.has(type)),
+        validator: (types) => types.every((type) => contentTypeIdMap.has(type)),
+        toInput: toStringArrayInput,
+        fromInput: fromArrayInput,
+      })
+      .add('assignedToWebsiteSectionIds', {
+        type: Array,
+        defaultValue: () => [],
+        toInput: toIntArrayInput,
+        fromInput: fromArrayInput,
+      })
+      .add('sortField', {
+        type: String,
+        defaultValue: defaultSortField,
+        validator: (v) => sortFieldSet.has(v),
+      })
+      .add('sortOrder', {
+        type: String,
+        defaultValue: 'DESC',
+        validator: (v) => sortOrderSet.has(v),
+      });
+  }
+
+  add(name, param) {
+    this.params.set(name, new MarkoWebSearchQueryParam({ ...param, name }));
+    return this;
+  }
+
+  names() {
+    return [...this.params.keys()].sort();
+  }
+
+  getDefinition(name) {
+    const param = this.params.get(name);
+    if (!param) throw new Error(`No query parameter definition was found for ${name}`);
+    return param;
+  }
+}
+
+module.exports = MarkoWebSearchQueryParamConfig;

package/index.js

@@ -0,0 +1,113 @@
+class MarkoWebSearch {
+  constructor({ config, query = {} } = {}) {
+    this.config = config;
+    this.query = query;
+    this.input = this.getAllInputValues();
+  }
+
+  buildURLSearchParams(newValues = {}, omit = {}) {
+    return new URLSearchParams(this.queryParamNames.reduce((o, name) => {
+      if (omit[name]) return o;
+      const value = this.getQueryStringValueFor(name, newValues[name]);
+      if (value == null) return o;
+      return { ...o, [name]: value };
+    }, {}));
+  }
+
+  buildQueryString(newValues = {}, omit = {}) {
+    const params = this.buildURLSearchParams(newValues, omit);
+    const str = `${params}`;
+    return str ? `?${str}` : '';
+  }
+
+  /**
+   * Gets all component (internal) input values from the current Express request query.
+   *
+   * Invalid values are reset to the definition's default value.
+   * @returns {object}
+   */
+  getAllInputValues() {
+    return this.queryParamNames.reduce((o, name) => {
+      const value = this.getInputValueFor(name);
+      return { ...o, [name]: value };
+    }, {});
+  }
+
+  /**
+   * Gets the component (internal) input value for the provided parameter name and
+   * current Express request query.
+   *
+   * Invalid values are reset to the definition's default value.
+   *
+   * @param {string} name The query parameter name.
+   * @param {object} query The Express request query object.
+   * @returns {*}
+   */
+  getInputValueFor(name) {
+    const definition = this.config.queryParams.getDefinition(name);
+    return definition.toInputValue(this.query[name], this);
+  }
+
+  isInputValueSelectedFor(name, incomingInput) {
+    const definition = this.config.queryParams.getDefinition(name);
+    const currentInput = this.getInputValueFor(name);
+    return definition.areInputsEqual(currentInput, incomingInput);
+  }
+
+  isDefaultInputValueFor(name) {
+    const definition = this.config.queryParams.getDefinition(name);
+    const input = this.getInputValueFor(name);
+    return definition.isDefaultValue(input);
+  }
+
+  isArrayParam(name) {
+    const definition = this.config.queryParams.getDefinition(name);
+    return definition.isArray();
+  }
+
+  /**
+   *
+   * @param {string} name The query parameter name
+   * @param {*} [newValue] The optional new value to replace
+   * @returns {string?}
+   */
+  getQueryStringValueFor(name, newValue) {
+    const definition = this.config.queryParams.getDefinition(name);
+    const value = typeof newValue === 'undefined' ? this.input[name] : newValue;
+    return definition.toQueryValue(value, this);
+  }
+
+  get queryParamNames() {
+    return this.config.queryParams.names();
+  }
+
+  getCurrentPage() {
+    return this.getInputValueFor('page');
+  }
+
+  getLimit() {
+    return this.getInputValueFor('limit');
+  }
+
+  getSkip() {
+    return this.getLimit() * (this.getCurrentPage() - 1);
+  }
+
+  getTotalPages(totalCount = 0) {
+    const count = totalCount > 10000 ? 10000 : totalCount;
+    return Math.ceil(count / this.getLimit());
+  }
+
+  getNextPage(totalCount = 0) {
+    const page = this.getCurrentPage();
+    const total = this.getTotalPages(totalCount);
+    return page < total ? page + 1 : null;
+  }
+
+  getPrevPage() {
+    const page = this.getCurrentPage();
+    return page > 1 ? page - 1 : null;
+  }
+}
+
+module.exports = MarkoWebSearch;

package/loaders/search.js

@@ -0,0 +1,108 @@
+const gql = require('graphql-tag');
+const { extractFragmentData } = require('@mindful-web/web-common/utils');
+
+const buildMindfulWebQuery = ({ queryFragment, opSuffix = '' } = {}) => {
+  const { spreadFragmentName, processedFragment } = extractFragmentData(queryFragment);
+  return gql`
+    query MarkoWebSearchContentIdsFromBrowse${opSuffix}($ids: [Int!]!, $limit: Int!) {
+      allContent(input: { ids: $ids, pagination: { limit: $limit } }) {
+        edges {
+          node {
+            id
+            ${spreadFragmentName}
+          }
+        }
+      }
+    }
+    ${processedFragment}
+  `;
+};
+
+const baseBrowseQuery = gql`
+  query MarkoWebSearchSearchContentIds($input: BrowseContentQueryInput!) {
+    searchContentIds(input: $input) {
+      totalCount
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+      }
+      ids
+    }
+  }
+`;
+
+/**
+ * @param {object} clients
+ * @param {ApolloClient} clients.apolloMindfulWebCMS The Mindful Web client that will perform the
+ * query.
+ * @param {ApolloClient} clients.apolloBaseBrowse The BaseBrowse client that will perform the query.
+ * @param {object} params
+ * @param {number} [params.limit]
+ * @param {number} [params.skip]
+ * @param {string} [params.sortField=PUBLISHED]
+ * @param {string} [params.sortOrder=DESC]
+ * @param {string} [params.searchQuery]
+ * @param {string[]} [params.contentTypes]
+ * @param {string[]} [params.countryCodes]
+ * @param {string[]} [params.assignedToWebsiteSiteIds]
+ * @param {number[]} [params.assignedToWebsiteSectionIds]
+ * @param {string} [params.queryFragment] The `graphql-tag` fragment
+ *                                        to apply to the `allContent` query.
+ * @param {string} [params.opSuffix] A suffix to add to the GraphQL operation name.
+ */
+module.exports = async ({ apolloMindfulWebCMS, apolloBaseBrowse } = {}, {
+  limit,
+  skip,
+
+  sortField = 'PUBLISHED',
+  sortOrder = 'DESC',
+
+  searchQuery,
+  contentTypes = [],
+  countryCodes = [],
+  assignedToWebsiteSiteIds = [],
+  assignedToWebsiteSectionIds = [],
+
+  queryFragment,
+  opSuffix,
+  searchType,
+} = {}) => {
+  if (!apolloMindfulWebCMS || !apolloBaseBrowse) throw new Error('Both the Mindful Web and Base Browse Apollo clients must be provided.');
+  const input = {
+    omitScheduledAndExpiredContent: true,
+    statuses: ['PUBLISHED'],
+    contentTypes,
+    countryCodes,
+    ...(searchQuery && { search: { query: searchQuery, type: searchType } }),
+    ...((assignedToWebsiteSiteIds.length || assignedToWebsiteSectionIds.length) && {
+      assignedToWebsites: {
+        ...(assignedToWebsiteSiteIds.length && { siteIds: assignedToWebsiteSiteIds }),
+        ...(assignedToWebsiteSectionIds.length && { sectionIds: assignedToWebsiteSectionIds }),
+      },
+    }),
+    pagination: { limit, skip },
+    sort: {
+      field: sortField,
+      order: sortOrder,
+    },
+  };
+
+  const { data: baseBrowseData } = await apolloBaseBrowse.query({
+    query: baseBrowseQuery,
+    variables: { input },
+  });
+
+  const { ids, pageInfo, totalCount } = baseBrowseData.searchContentIds;
+  if (!ids.length) return { nodes: [], pageInfo, totalCount };
+
+  const { data } = await apolloMindfulWebCMS.query({
+    query: buildMindfulWebQuery({ queryFragment, opSuffix }),
+    variables: { ids, limit: ids.length },
+  });
+  const nodes = data.allContent.edges
+    .map((edge) => (edge && edge.node ? edge.node : null))
+    .filter((c) => c);
+  const map = nodes.reduce((m, node) => m.set(`${node.id}`, node), new Map());
+  const ordered = ids.map((id) => map.get(`${id}`)).filter((node) => node);
+  return { nodes: ordered, pageInfo, totalCount };
+};

package/marko.json

@@ -0,0 +1,6 @@
+{
+  "taglib-id": "@mindful-web/marko-search",
+  "taglib-imports": [
+    "./components/marko.json"
+  ]
+}

package/middleware.js

@@ -0,0 +1,9 @@
+const MarkoWebSearch = require('./index');
+
+module.exports = ({ config, template } = {}) => (req, res) => {
+  res.locals.$markoWebSearch = new MarkoWebSearch({
+    config,
+    query: req.query,
+  });
+  return res.marko(template);
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@mindful-web/marko-web-search",
+  "version": "1.0.0",
+  "author": "Jacob Bare <jacob@parameter1.com>",
+  "repository": "https://github.com/parameter1/mindful-web/tree/main/packages/marko-web-search",
+  "license": "MIT",
+  "scripts": {
+    "lint:fix": "yarn lint --fix",
+    "lint": "eslint --ext .js --ext .vue --max-warnings 5 ./",
+    "compile": "mindful-web-marko-compile compile",
+    "prepublish": "yarn compile --silent",
+    "test": "yarn compile --no-clean && yarn lint"
+  },
+  "dependencies": {
+    "@mindful-web/inflector": "^1.0.0",
+    "@mindful-web/marko-web-icons": "^1.0.0",
+    "@mindful-web/object-path": "^1.0.0",
+    "@mindful-web/utils": "^1.0.0",
+    "@mindful-web/web-common": "^1.0.0",
+    "@parameter1/joi": "^1.2.10",
+    "graphql": "^14.7.0",
+    "graphql-tag": "^2.12.6"
+  },
+  "peerDependencies": {
+    "@mindful-web/marko-core": "^0.0.0",
+    "@mindful-web/marko-web": "^0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "0b77cab713eb5841202bb86c7119949866bc68b5"
+}