How to use the graphql-subscriptions.withFilter function in graphql-subscriptions

export const TeamsSubscriptions = {
  teamsUpdate: {
    resolve(rootValue, { simulatorId, type, cleared }) {
      // Get the simulator
      let returnVal = rootValue;
      if (type) {
        returnVal = returnVal.filter(t => t.type === type);
      }
      if (simulatorId) {
        returnVal = returnVal.filter(t => t.simulatorId === simulatorId);
      }
      if (cleared) return returnVal;
      return returnVal.filter(c => !c.cleared);
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("teamsUpdate"),
      (rootValue, { simulatorId, type }) => true
    )
  }
};

export const TeamsTypes = {
  Team: {
    location(team) {
      const deck = App.decks.find(d => d.id === team.location);
      if (deck) {
        return deck;
      }
      return App.rooms.find(r => r.id === team.location);
    },
    officers(team) {

import { withFilter } from 'graphql-subscriptions';
import { getThread } from '../models/thread';
import { userCanViewChannel, userCanViewDirectMessageThread } from './utils';
const { listenToNewMessages } = require('../models/message');
import asyncify from '../utils/asyncify';
import { trackUserThreadLastSeenQueue } from 'shared/bull/queues.js';
import type { Message } from '../models/message';

/**
 * Define the message subscription resolvers
 */
module.exports = {
  Subscription: {
    messageAdded: {
      resolve: (message: any) => message,
      subscribe: withFilter(
        asyncify(listenToNewMessages, err => {
          throw new Error(err);
        }),
        async (message, { thread }, { user }) => {
          // Message was sent in different thread, early return
          if (message.threadId !== thread) return false;
          if (message.threadType === 'directMessageThread') {
            if (!user) return false;
            return userCanViewDirectMessageThread(message.threadId, user.id);
          }

          const threadData = await getThread(message.threadId);
          if (!threadData) return false;

          return await userCanViewChannel(
            threadData.channelId,

}
})


export default {
  // auth stuffs
  newComment: {
    type: CommentType,
    args: {
      input: {
        type: NewCommentSubscriptionInput
      }
    },
    // resolve have to be there... dont know why yet
    resolve: data => data,
    subscribe: withFilter(
      () => pubsub.asyncIterator(SubsTypes.NewComment), (payload, variables = {}, context) => {
        // TODO: can't add context in playground and test subscription without frontend
        // disable auth for dev env?
        if (isNilOrEmpty(context.user)) {
          return false
        }
        const globalReportId = variables.input && variables.input.reportId
        const reportId = Number(fromGlobalId(globalReportId).id)
        return payload.report_id === reportId
      }
    ),
  }
}

links: () => db.links
  },
  Mutation: {
    createLink: (_, { url, description }) => {
      const link = { id: shortid.generate(), description, url };
      db.links.push(link);
      pubsub.publish(CHANNEL.LINK, { [SUBSCRIPTION.LINK]: link });
      return link;
    }
  },
  Subscription: {
    [SUBSCRIPTION.LINK]: {
      resolve: (payload, args, context, info) => {
        return payload.link;
      },
      subscribe: withFilter(
        (rootValue, args, context, info) => {
          return pubsub.asyncIterator(CHANNEL.LINK);
        },
        (payload, variables, context, info) => {
          console.log('payload: ', payload);
          console.log('variables: ', variables);
          return true;
        }
      )
    }
  }
};

const schema = makeExecutableSchema({
  typeDefs,
  resolvers

(rootValue, { simulatorId }) => {
        if (simulatorId)
          return !!rootValue.find(s => s.simulatorId === simulatorId);
        return true;
      }
    )
  },
  coolantSystemUpdate: {
    resolve(rootValue, { simulatorId, systemId }) {
      let returnRes = rootValue;
      if (simulatorId)
        returnRes = returnRes.filter(s => s.simulatorId === simulatorId);
      if (systemId) returnRes = returnRes.filter(s => s.id === systemId);
      return returnRes;
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("coolantSystemUpdate"),
      (rootValue, { simulatorId, systemId }) => {
        let returnRes = rootValue;
        if (simulatorId)
          returnRes = returnRes.filter(s => s.simulatorId === simulatorId);
        if (systemId) returnRes = returnRes.filter(s => s.id === systemId);
        return returnRes.length > 0 ? true : false;
      }
    )
  }
};

},
  showViewscreenTactical(rootValue, args, context) {
    App.handleEvent(args, "showViewscreenTactical", context);
  }
};

export const TacticalMapSubscriptions = {
  tacticalMapsUpdate: {
    resolve(rootValue, { flightId }) {
      let returnRes = rootValue;
      if (flightId) {
        returnRes = returnRes.filter(s => s.flightId === flightId);
      }
      return returnRes;
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("tacticalMapsUpdate"),
      (rootValue, { flightId }) => {
        if (flightId) {
          return rootValue.filter(s => s.flightId === flightId).length > 0;
        }
        return !!(rootValue && rootValue.length);
      }
    )
  },
  tacticalMapUpdate: {
    resolve(rootValue, { id }) {
      return rootValue;
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("tacticalMapUpdate"),
      (rootValue, { id }) => {

App.handleEvent({ layout }, "updateCoreLayout", context);
  },
  addCoreLayout(_, { layout }, context) {
    App.handleEvent({ layout }, "addCoreLayout", context);
  },
  removeCoreLayout(_, { id }, context) {
    App.handleEvent({ id }, "removeCoreLayout", context);
  }
};

export const CoreLayoutSubscriptions = {
  coreLayoutChange: {
    resolve(rootValue) {
      return rootValue;
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("coreLayoutChange"),
      rootValue => {
        return !!(rootValue && rootValue.length);
      }
    )
  }
};

App.handleEvent(args, "activateThx", context);
  },
  deactivateThx(root, args, context) {
    App.handleEvent(args, "deactivateThx", context);
  },
  resetThx(root, args, context) {
    App.handleEvent(args, "resetThx", context);
  }
};

export const ThxSubscriptions = {
  thxUpdate: {
    resolve(rootValue, { simulatorId }) {
      return rootValue.filter(s => s.simulatorId === simulatorId);
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("thxUpdate"),
      (rootValue, { simulatorId }) => {
        if (simulatorId) {
          return !!rootValue.find(s => s.simulatorId === simulatorId);
        }
        return true;
      }
    )
  }
};

setTransporterTargets(_, { transporter, targets }, context) {
    App.handleEvent({ transporter, targets }, "setTransporterTargets", context);
    return "";
  },
  setTransporterChargeSpeed(root, args, context) {
    App.handleEvent(args, "setTransporterChargeSpeed", context);
  }
};

export const TransporterSubscriptions = {
  transporterUpdate: {
    resolve(rootValue, { simulatorId }) {
      if (rootValue.simulatorId !== simulatorId) return false;
      return rootValue;
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("transporterUpdate"),
      rootValue => !!rootValue
    )
  }
};

App.handleEvent(args, "updateSoftwarePanel", context);
  },
  removeSoftwarePanel(rootValue, args, context) {
    App.handleEvent(args, "removeSoftwarePanel", context);
  }
};

export const SoftwarePanelsSubscriptions = {
  softwarePanelsUpdate: {
    resolve(rootValue, { simulatorId }) {
      if (simulatorId) {
        return rootValue.filter(s => s.simulatorId === simulatorId);
      }
      return rootValue.filter(s => !s.simulatorId);
    },
    subscribe: withFilter(
      () => pubsub.asyncIterator("softwarePanelsUpdate"),
      rootValue => !!(rootValue && rootValue.length)
    )
  }
};