@draftbox-co/gatsby-plugin-fusejs/gatsby-node.js

A Gatsby plugin for the lightweight fuzzy search library fusejs

const Fuse = require('fuse.js');

const fs = require('fs');

const path = require('path');

const createOrGetIndex = (fields, dataArray) => {
  if (fs.existsSync(path.join(__dirname, 'fuse-index.json'))) {
    const fuseIndexJSON = require(path.join(__dirname, 'fuse-index.json'));

    return fuseIndexJSON;
  } else {
    const fuseIndex = Fuse.createIndex(fields, dataArray);
    fs.writeFileSync(path.join(__dirname, 'fuse-index.json'), JSON.stringify(fuseIndex.toJSON()));
    return fuseIndex;
  }
};

exports.createSchemaCustomization = ({
  actions,
  schema
}, {
  resolvers
}) => {
  const {
    createTypes
  } = actions;
  const typedefs = [schema.buildScalarType({
    name: 'Index',
    description: 'Serialized FuseJS Index',

    parseValue() {
      throw new Error(`Not supported`);
    },

    serialize(value) {
      return value;
    },

    parseLiteral() {
      throw new Error(`Not supported`);
    }

  }), schema.buildObjectType({
    name: 'FuseIndex',
    fields: {
      index: "Index!"
    },
    interfaces: ["Node"]
  })];
  createTypes(typedefs);
};

exports.onPostBootstrap = ({
  getNodesByType,
  getNode,
  reporter
}, {
  fields,
  resolvers
}) => {
  if (fields.length === 0) {
    reporter.error('fields should not be empty');
  }

  if (Object.keys(resolvers).length === 0) {
    reporter.error('resolvers are not defined');
  }

  const resolverType = Object.keys(resolvers)[0];
  const docNodes = getNodesByType(resolverType);

  if (docNodes.length === 0) {
    reporter.warn('No data found for given node type');
  }

  const docsArray = docNodes.map(node => {
    const returnJson = {};

    for (const key in resolvers[resolverType]) {
      returnJson[key] = resolvers[resolverType][key](node, getNode);
    }

    return returnJson;
  });
  fs.existsSync(path.join(__dirname, 'fuse-index.json')) && fs.unlinkSync(path.join(__dirname, 'fuse-index.json'));
  createOrGetIndex(fields, docsArray);
};

exports.createResolvers = async ({
  actions,
  cache,
  createNodeId,
  createResolvers,
  store,
  reporter
}, {
  fields,
  resolvers
}) => {
  createResolvers({
    Query: {
      fuseIndex: {
        type: `FuseIndex`,

        async resolve(source, args, context, info) {
          const fuseIndex = createOrGetIndex(fields, []);
          return {
            index: fuseIndex
          };
        }

      }
    }
  });
};