In an attempt to create a mockAPI with hot reload functionality, I encountered an issue. Whenever I edit the schema or the data returned by the server and restart it, the changes are not reflected (I tested this using Postman).

I believed that restarting the server after making edits to the schema or data would solve the issue. However, even utilizing a callback function within graphqlHTTP to listen for changes in the schema and rootValue did not work.

Please note: I do not want to terminate the Node process!

index.js

/** Require file system */
const fs = require('fs');
const md5 = require('md5');
const path = require('path');
const { readFileSync } = require('fs');
/** Start MockAPI */
const http = require('http');
const expressModule = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

module.exports = class mockAPI {
  constructor(options = { host: '127.0.0.1', port: 3000, namespace: '' }) {
    /** Initialize express */
    this.modules();

    this.directories = {
      data: './data',
      schema: './schema'
    };

    this.ignore = ['.DS_Store', 'Thumbs.db'];

    this.host = options.host;
    this.port = options.port;
    this.namespace = options.namespace;

    this.registerRoutes({
      data: this.getRoutes(this.directories.data),
      schema: this.getRoutes(this.directories.schema)
    });

    /** Begin watching for changes (true) */
    this.start(true);
  }

  modules() {
    /** Initialize express */
    this.express = expressModule();
    this.server = http.createServer(this.express);
  }

  start(watch) {
    /** Start server */
    return new Promise((resolve, reject) => {
      this.server
        .listen(this.port, this.host, () => {
          const restart = !watch ? 're' : '';

          console.info(
            '\x1b[1m\x1b[32m%s\x1b[0m\x1b[0m',
            `\n> MockAPI server ${restart}open on ... http://${this.server.address().address}:${this.server.address().port}\n`
          );
          /** Begin watching API files */
          if (watch) this.watch(this.directories);
        })
        .on('error', err => {
          if (err) reject(err);
        });

      resolve();
    });
  }

  stop(restart) {
    /** Stop server */
    return new Promise((resolve, reject) => {
      this.server.close(err => {
        if (err) reject(err);

        const color = restart ? '33' : '31';
        const message = restart ? 'restart' : 'closed';

        console.info(
          `\x1b[1m\x1b[${color}m%s\x1b[0m\x1b[0m`,
          `> MockAPI server ${message} on ... http://${this.host}:${this.port}`
        );

        resolve();
      });
    });
  }

  watch(directories) {
    this.md5Previous = null;
    this.fsWait = false;

    Object.keys(directories).map(key => {
      const dir = directories[key];

      fs.watch(path.resolve(__dirname, dir), { recursive: true }, (event, filename) => {
        if (event === 'change' && filename) {
          /** Avoid executing multiple times while saving */
          if (this.fsWait) return false;

          const md5Current = md5(fs.readFileSync(path.resolve(__dirname, `${dir}/${filename}`));
          /** Compare file hashes */
          if (md5Current === this.md5Previous) return false;

          /** Restart server */
          this.fsWait = true;
          setTimeout(async () => {
            this.fsWait = false;
            this.md5Previous = md5Current;

            console.info('\x1b[33m%s\x1b[0m', `- ${filename} changed`);
            await this.server.removeAllListeners('upgrade');
            await this.server.removeAllListeners('request');

            await this.stop(true);

            await this.modules();
            await this.registerRoutes({
              data: this.getRoutes(this.directories.data),
              schema: this.getRoutes(this.directories.schema)
            });

            this.start(false);
          }, 1000);
        }
      });
    });

    return true;
  }

  getRoutes(dir) {
    const absPath = path.resolve(__dirname, dir);
    let routes = [];

    const readDir = path => {
      let data = [];

      fs.readdirSync(path, { withFileTypes: true }).forEach(file => {
        if (this.ignore.includes(file.name)) return false;

        if (file.isDirectory()) return readDir(`${path}/${file.name}`);

        const route = path === absPath ? '' : path.replace(absPath, '');
        const name = file.name.replace(/\.js|\.graphql/, '');
        const endpoint = name.replace(/\s+/g, '-');

        data.push({
          name: name,
          dir: route,
          file: file.name,
          route: `${route}/${endpoint}`
        });
      });

      routes = [...routes, ...data];
    };
    readDir(absPath);
    /** Sort array by route */
    return routes.sort((a, b) => a.route.localeCompare(b.route));
  }

  registerRoutes(routes) {
    if (routes.schema.length !== routes.data.length) {
      console.error(
        '\x1b[31m%s\x1b[0m',
        `- schema.length(${routes.schema.length}) !== data.length(${routes.data.length}).\n  Each schema must match a data file in the same file structure with the same file name.`
      );
      process.exit;
    }

    routes.data.forEach(async (vdata, key) => {
      if (vdata.route === routes.schema[key].route) {
        const typeDefs = await readFileSync(`./mock-api/schema${routes.schema[key].dir}/${routes.schema[key].file}`).toString('utf-8');

        let schema = await buildSchema(typeDefs);
        let data = await require(`./data${vdata.dir}/${vdata.file}`);

        this.express.use(
          this.namespace + vdata.route,
          graphqlHTTP({
            schema: schema,
            rootValue: data,
            graphiql: true
          })
        );
      }
    });
  }
};

I would appreciate any assistance in resolving this issue.

To replicate the process, simply create directories /data and /schema in the same root directory as this code/snippet/file and run any yarn or npm command to load this module (index.js). Place a JS file in the /data directory to define the resolvers and a GraphQL file in the /schema directory to define the schema. Both files must have the same name to match the route registered based on the file structure.

For example, if you place /data/test/data.js in /data, write the schema in /schema/test/data.graphql, and access it via .

Below are examples for quick replication:

data.js

/**
 * Returns GraphQL data
 * @returns {object} data
 */
module.exports = {
  hello: () => {
    return 'Hello world!';
  }
};

data.graphql

type Query {
  hello: String
}

What I require is a method to flush, clear, delete, or otherwise remove the stored data.