How to use the fs-jetpack.find function in fs-jetpack

loadResolvers() {
    const { baseDir } = this.app;
    const appDir = join(baseDir, 'app');
    let resolvers: any[] = [];

    if (!existsSync(appDir)) {
      this.app.logger.warn('[egg-type-graphql]', '缺少 resolver 文件');
      return [];
    }

    // TODO: handle other env
    const matching = this.app.config.env === 'local' ? '*.resolver.ts' : '*.resolver.js';
    const files = find(appDir, { matching });

    if (!files.length) {
      this.app.logger.error('[egg-type-graphql]', '缺少 resolver');
      return [];
    }

    try {
      for (const file of files) {
        const resolverPath = join(baseDir, file);
        const resolversFromFile = this.getResolverClassFromFile(resolverPath);
        if (!resolversFromFile.length) {
          this.app.logger.error('[egg-type-graphql]', `${file} 文件必须存在至少一Resolver`);
        }
        resolvers = [ ...resolvers, ...resolversFromFile ];
      }
    } catch (e) {

loadResolvers() {
        const { baseDir } = this.app;
        const graphqlDir = path_1.join(baseDir, 'app', 'graphql');
        const resolvers = [];
        if (!fs_1.existsSync(graphqlDir))
            return [];
        // TODO: handle other env
        const matching = this.app.config.env === 'local' ? '*resolver.ts' : '*resolver.js';
        const files = fs_jetpack_1.find(graphqlDir, { matching });
        try {
            for (const file of files) {
                const resolverPath = path_1.join(baseDir, file);
                const resolver = require(resolverPath).default;
                resolvers.push(resolver);
            }
        }
        catch (e) {
            this.app.logger.error('[egg-type-graphql]', JSON.stringify(e));
        }
        return resolvers;
    }
    async getSchema() {

getDirectives() {
    const { baseDir } = this.app;
    const directivesDir = join(baseDir, 'app', 'directive');
    if (!existsSync(directivesDir)) return {};

    const matching = this.app.config.env === 'local' ? '*.ts' : '*.js';
    const files = find(directivesDir, { matching });
    return files.reduce(
      (prev, cur) => {
        const directivePath = join(baseDir, cur);
        const name = basename(directivePath).replace(/(.ts)|(.js)$/, '');
        return {
          ...prev,
          [name]: require(directivePath).default,
        };
      },
      {} as any,
    );
  }

fh.getDirectories = function(path) {
    if (jetpack.exists(path) !== 'dir') return [];
    return jetpack.find(path, {
        matching: '*',
        files: false,
        directories: true,
        recursive: false
    }).map(path => jetpack.path(path));
};

function loadSpec () {
  const spec = {};
  const snippetFiles = jetpack.find(`${__dirname}/hms_data`, {
    matching: '*.json'
  });
  snippetFiles.forEach(function (filename) {
    const snippet = jetpack.read(filename, 'json');
    if (typeof snippet.groups === 'undefined') {
      snippet.groups = [];
    }
    if (snippet.phrases) {
      snippet.groups.push({
        tags: [],
        phrases: snippet.phrases
      });
    }
    spec[snippet.name] = snippet;
  });
  return spec;

code += '    "attributes": [';
      code += attributes.map(toOneLiner);
      code += (attributes.length ? '\n    ' : '') + '],\n';
      code += '    "extensions": [';
      code += extensions.map(toOneLiner);
      code += (extensions.length ? '\n    ' : '') + ']\n';
      code += '  },\n';
    }
    return `[\n${code.slice(0, -2)}\n]`;
  };
})();

let indent = (str, num) => str.replace(/\n/g, '\n'+' '.repeat(num));
let path = './cocos/3d/builtin/effects';
let dest = path_.join(path, 'index.json');
let files = fsJetpack.find(path, { matching: ['**/*.effect'] }), code = ``;
for (let i = 0; i < files.length; ++i) {
  let name = path_.basename(files[i], '.effect');
  let content = fs.readFileSync(files[i], { encoding: 'utf8' });
  let effect = shdcLib.buildEffect(name, content);
  code += '  {\n';
  code += `    "name": "${effect.name}",\n`;
  code += `    "techniques": ${JSON.stringify(effect.techniques)},\n`;
  code += `    "properties": ${JSON.stringify(effect.properties)},\n`;
  code += `    "shaders": ${indent(stringifyShaders(effect.shaders), 4)}\n`;
  code += '  },\n';
}
fs.writeFileSync(dest, `[\n${code.slice(0, -2)}\n]\n`, { encoding: 'utf8' });

export const createRouterConfig = () => {
  fs.ensureDirSync(tmpConfigDir)

  if (fs.existsSync(routerConfigPath)) {
    writeFileFromRoutesFile()
    return
  }

  const pages = jetpack.find(pagesDir, { matching: '**/*.tsx' })
  const routesText = getRoutesConfig(pages)
  const code = formatCode(routesText)
  writeFile(code)
}

readAllJSONFilesFromDirectory(directoryPath, matching = '*/*.json') {

        if(!this.folderExists(directoryPath)) return Promise.resolve([]);

        const files = jetpack.find(directoryPath, {
            matching,
            recursive: true
        });
        const filesToRead = files.map(file => this.readFile(file));

        return Promise.all(filesToRead);
    }