Hi, any ideas about how to use this Flexsearch function together with this plugin?
Or any other way how to replace special characters with required characters?
FlexSearch.registerMatcher({
'ä': 'a', // replaces all 'ä' to 'a'
'ó': 'o',
'[ûúù]': 'u' // replaces multiple
});
Thank you

Hi. Because I'm Korean. So I want to set a custom tokenizer for my korean posts.
How can I do it?

For now i have query mostly title to do the search over all pages but i would like to search in more fields (all fields), as i have many indent fields in relationships, its complicated as there are many types of fields.
The defaulf options in flex seems not working in my query. Any recommendations.

I use gatsby-plugin-local-search together with react-use-flexsearch. My index and store coming from graphql are both strings. That causes useFlexsearch(query, index, store) not to work, because it uses an array access store[id], which fails when the store is a string instead of an object.

My workaround is useFlexSearch(query, index, JSON.parse(store)), but I think either gatsby-plugin-local-search or react-use-flexsearch should do the conversion instead.

https://github.com/kbrsh/wade

• Much smaller runtime library than lunr and FlexSearch.

In query I would like to have a dynamic variable to filter, that variable would be like a context variable, is that possible?

Hello,

let's say I have
sections : [{"section: "Economy", url: '/economy'}, {"section: "Fun", url: '/fun'}]
articles: [{id: 1, "section: "Economy", title, url}, {id: 2, "section: "Economy", title, url}, {id: 3, "section: "Fun", title, url}]

and when I query "economy" I'd like to get something like this:

Sections:
Economy

Articles:
Title (from Economy)
Title 2 (from Economy)

where the query is either in sections section key, or article title.

Would you suggest to use multiple useFlexSearch hooks and multiple gatsby-plugin-local-search instances, or is there any simple way how to connect the data in normalizer as I could query multiple object types and filtering the results somehow later in render function?

Thank you very much for any insight. Even pointing me in any direction would be great :)

just a mistake

If you try to tokenize value with custom function in engineOptions section:

engineOptions: {
   profile: "speed",
   tokenize: function(str) {
      console.log(typeof(str), str) // <= here you'll get something like 'string' '{"name": "Itemname"}' not just Itemname
       return someTokenizeFunction(str)
   }

Loving this plugin. Thanks for your work.

I am querying data from Prismic but I have multiple data nodes from Prismic. I know that I can initialise multiple instances of gatsby-plugin-local-search but that will return multiple data nodes again. What I would like to do it query all of the data types from Prismic in the one instance and map each to the resolver. This is more difficuld as each node has a different shape.

e.g.

query: `
          {
            allPrismicArticle {
              edges {
                node {
                  id
                  slugs
                  data {
                    article_title {
                      text
                    }
                    content {
                      text
                    }
                  }
                }
              }
            }
            allPrismicCaseStudy {
              edges {
                node {
                  id
                  data {
                    title {
                      text
                    }
                  }
                  dataString
                }
              }
            }
          }
        `,

And the normalize function looks like this.

normalizer: ({ data }) =>
  data.allPrismicArticle.edges.map(edge => ({
    id: edge.node.id,
    title: edge.node.data.article_title.text,
    content: edge.node.data.content.text
})),

How do I map both allPrismicCaseStudy & allPrismicArticle?

A new major version of FlexSearch 0.7.0 has been released that might have some breaking changes.

Hello!

I'm wondering if it's possible or even advised to query sharp images on this plugin's config so I can display them as thumbnails on my results.

Using ...GatsbyImageSharpFluid fragment breaks build, and deconstructing this fragment on my query results in a image with weird colors.

Hi,

Thanks for this great plugin. I've got a basic implementation working with content sourced from Prismic and it's blazingly fast...

However, because Prismic has a 20 document limit on their API the index is only being populated with the first 20 items. So, I was wondering whether it might be possible to utilise the cursors Prismic returns to fetch all content.

If, as @angeloashmore says, the query option accepted a function we could have some kind of loop that fetches all the documents using cursors (original post here).

Any guidance would be really welcomed.

Many thanks

Hello,

first of all, thank's for this awesome plugin...

I use it with useFlexSearch from react-use-flexsearch but I am unable to find out why this happens and how to get rid of it.

Let's say I have data:
[{ first_name: "Alpha" last_name: "Beta" },{ first_name: "Beta" last_name: "Gamma" }]
and config set to engine: "flexsearch", engineOptions: { encode: "icase", tokenize: "strict"}

Everything works fine (with query 'Alpha' || 'Delta' returns 1 result, 'Beta' 2), but query 'first_name' or 'last_name' returns both objects as result. When I use more advanced tokenization, even 'first' returns everything, etc.

Any idea how to get rid of this behavior? It's getting problematic when I have "email" as a key and values like "@email.de" which then shows all users. I am clueless how to approach this.

Thank you very much.

Having issues for pulling separate indexes for different pages.

Current:

/my-site/page1

query SearchbarIndexQuery {
  localSearchPage1 {
    index
    store
  }

/my-site/another-page

query SearchbarIndexQuery {
  localSearchAnotherPage {
    index
    store
  }

Preferred:

query($indexName: String) {
  localSearchPages(filter: {indexName: {eq: $indexName}}) {
    index
    store
  }

Because gatsby tries to validate pageQueries on compile time the current version requires a dynamic string to be passed in, unless theres a better approach?

https://www.gatsbyjs.org/packages/gatsby-plugin-local-search/?=search

Heyo! Not sure if this is something you'd be concerned by or what, but it appears a dependency you use has been deprecated: https://www.npmjs.com/package/pascal-case

Hey, I propose to setup the Gatsby plugin options validation tool in this plugin.

This will bring few things:

• Validation of options when gatsby is started, so less options validation in the main code
• Possibility to generate documentation based on the validation schema
• Possibility to generate the Typescript types based on the validation schema

See an example in the gatsby wordpress plugin https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-wordpress/src/steps/declare-plugin-options-schema.ts

Add an index option that lives alongside store that, similar to store, allows one to select which fields are indexed.

By default, index is all keys returned by normalizer.

This effectively turns normalizer into a data normalizer where content can be selected. This allows someone to keep data in the store, but not indexed, if such data is only used for presentation.

I followed the instructions of this and that repo, for a gatsby site with gatsby-json-tranformer as data source.

I have a query, index, & store; but react-use-flexsearch is returning an array of chars...
Do you have a working sample repo we could give a try?

given your how to use, consider this scenario:
-Search by title but not by body
-When a title is found, pull the body data

The way I've been using it, is searching all data, and that had a severe performance downgrade in the lighthouse test.

I can't use a query that contains the metadata of my pages, because for the lib it is empty but when I query in the graphql IDE it returns me all the results, does it have something to do with the order of execution? how to fix this?

my config

module.exports = {
  // A unique name for the search index. This should be descriptive of
  // what the index contains. This is required.
  name: 'pages_metadata',

  // Set the search engine to create the index. This is required.
  // The following engines are supported: flexsearch, lunr
  engine: 'flexsearch',

  // Provide options to the engine. This is optional and only recommended
  // for advanced users.
  //
  // Note: Only the flexsearch engine supports options.
  // engineOptions: 'speed',

  // GraphQL query used to fetch all data for the search index. This is
  // required.
  query: `{
    allPagesIndexable {
      nodes {
        path
        metadata {
          content
          keywords
          title
          type
        }
      }
    }
  }`,
  // Field used as the reference value for each document.
  // Default: 'id'.
  ref: 'path',

  // List of keys to index. The values of the keys are taken from the
  // normalizer function below.
  // Default: all fields
  index: ['title', 'keywords', 'content'],

  // List of keys to store and make available in your UI. The values of
  // the keys are taken from the normalizer function below.
  // Default: all fields
  // store: ['id', 'path', 'title'],

  // Function used to map the result from the GraphQL query. This should
  // return an array of items to index in the form of flat objects
  // containing properties to index. The objects must contain the `ref`
  // field above (default: 'id'). This is required.
  normalizer: ({ data }) => {
    console.log(data.allPagesIndexable) // return [Object: null prototype] { nodes: [] }
    return data.allPagesIndexable.nodes.map(node => ({
      path: node.path,
      ...node.metadata
    }))
  }
}

example of result of my query in IDE:

{
  "data": {
    "allPagesIndexable": {
      "nodes": [
        {
          "path": "/curso/graduacao/contador-global",
          "metadata": {
            "content": null,
            "keywords": null,
            "title": null,
            "type": "Página"
          }
        },
        {
          "path": "/curso/graduacao/contador-global/informacoes-adicionais",
          "metadata": {
            "content": null,
            "keywords": null,
            "title": null,
            "type": "Página"
          }
        },
...
    

I created this separate node because I was having "metadata does not exist in context" problems when the query was executed by this lib
how i create the node:

exports.onCreateNode = ({ node, actions, createNodeId, createContentDigest }) => {
  const { createNode } = actions
  // Transform the new node here and create a new node or
  // create a new node field
  if (node.internal.type === "SitePage" && node.context && node.context.metadata) {
    const page = {
      path: node.path,
      metadata: node.context.metadata
    }
    createNode({
      ...page,
      id: createNodeId(page.path),
      internal: {
        type: `PagesIndexable`,
        contentDigest: createContentDigest(page)
      }
    })
  }
}

In the gatsby-config example, it says for index and store there's an 'default' option to expose all fields.
However it's not self-explanatory and I tried several options whitout success.

Anybody can explain how I can expose all the properties of normalizer without writing what fields should be in index and store ?

    // List of keys to index. The values of the keys are taken from the
    // normalizer function below.
    // Default: all fields
    index: ['title', 'body'],

    // List of keys to store and make available in your UI. The values of
    // the keys are taken from the normalizer function below.
    // Default: all fields
    store: ['id', 'path', 'title'],

When Lunr engine is used the index option is omitted and all fields from the normalizer are used.

This line always resolves to all fields in the document.

Add language support.

To support multiple engines, the best API is probably passing a language string (e.g. “en” or “de”).

Alternatively, allow passing arbitrary Stemmer configs. This would be engine-specific.

I'm using gatsby-node.js to create a bunch of pages which I would like to search through using your plugin. I'm passing all the needed data into the pagecontext during the creation of the pages.

My query looks like this:

 query: `
      {
        allSitePage {
          edges {
            node {
              path
              context {
                id__normalized
                market_cap_rank
                name
                symbol
              }
            }
          }
        }
      }
        `,

The error says: Cannot query field "context" on type "SitePage".

I'm not really sure if this just isn't supported or whether I am overlooking something here. The only thing that I can see that seems fishy to me is that the "success create pages" message in the console comes after the error, which makes me think that the pages don't exist yet when I'm trying to query them.

Any hints would be much appreciated! :)

The plugin currently saves indices and stores in Gatsby's node system. Retrieving them can be done by querying for them in a page's GraphQL query. If done directly in a page's query, the large indices and stores end up in the site's bundle.

To prevent bloating the site's bundle, the objects can be lazy-loaded by saving to files in the /public folder. The files can then be fetched client-side only when needed, such as the user's first search.

This can currently be done by querying for the objects in gatsby-node.js and saving the files manually using fs. This could be a feature provided by the plugin, however, by adding two new fields and a custom resolver:

query SearchPage {
  localSearchBlogPosts {
    publicIndexURL
    publicStoreURL
  }
}

Which could have a response like:

{
  "data": {
    "localSearchBlogPosts": {
      "publicIndexURL": "/static/6a992d5529f459a44fee58c733255e86.index.txt",
      "publicStoreURL": "/static/6a992d5529f459a44fee58c733255e86.store.json",
    }
  }
}

When someone queries for publicIndexURL or publicStoreURL, the relevant file is written to /public/static/ with an appropriate filename and returned in the query as a string. This removes the need to manage where the file is stored and allows different search engines to save files in their native format.

Note that this is modeled after gatsby-source-filesystem's publicURL field which performs a similar function.

This feature would not replace the direct index and store fields.