How to use the ejs.renderFile function in ejs

if (!user) return res.status(404).json({code: 1003, msg: 'email_not_found'});

        // generate token
        var hash = tokens.resetToken.generateHash({
            email: condition.email,
            password: user.passwd,
            expires: Date.now() + 86400000
        });

        var templateFile = path.resolve('src/server/template', 'reset_passwd_email.html');

        var domain = utils.getDomain();
        var resetUrl = domain + "/reset/" + hash;

        ejs.renderFile(templateFile, {
            siteUrl: domain,
            resetUrl: resetUrl
        }, {cache: true}, function (err, html) {
            if (err) return next(err);

            // setup email data with unicode symbols
            var mailOptions = {};

            mailOptions.subject = 'UUChat Password Reset';
            mailOptions.from = nconf.get('mail:auth:user');
            mailOptions.to = condition.email;
            mailOptions.html = html;

            Email.send(mailOptions, function (err, info) {
                if (err) logger.error(err);

} else {
                        return match;
                    }
                });

            if (!pack['repository']) {
                var lastAtSignPos = packageName.lastIndexOf('@');
                var mainName = packageName.substring(0, lastAtSignPos);

                if (missingRepos[mainName]) {
                    pack['repository'] = missingRepos[mainName];
                }
            }
        }

        ejs.renderFile(templatePath, {
            packages: packages,
            projVersion: packageJson.version,
            projName: packageJson.description
        }, {}, (err, mdText) => {
            if (err) {
                console.log(err);
            } else {
                fs.writeFileSync(`license-info-${packageJson.version}.md`, mdText);
                console.log(`Wrote license`);
            }
        });
    }
});

componentNames.forEach(async (componentName) => {
    console.log(`generating static index.html file for ${componentName}`);

    const data = {
        componentName,
        tagName: tagNameMap[componentName] || "",
    }

    const componentIndexContent = await ejs.renderFile("webapp/playground/component/Name/index.ejs", data);
    mkdirp.sync(`dist/playground/components/${componentName}/`);
    fs.writeFileSync(`dist/playground/components/${componentName}/index.html`, componentIndexContent);
});

private static RenderWebContent(context: vscode.ExtensionContext, path: string, data: any): Thenable {
        data.moment = moment;
        data.uniqid = uniqid;
        data.nomedia = WebView.noMedia;
        return ejs.renderFile(context.asAbsolutePath(path), data);
    }
}

type: input.property('type'),
        required: input.isRequired() && input.isEmpty(),
        vector: input.isVector(),
        description: inputDescription,
        typeHint: webTypeHint,
      });
    }

    const data = {
      method: this.request().method,
      routePath: this.request().route.path,
      description: this.action().meta('description', ''),
      inputs: inputData,
    };

    return ejs.renderFile(
      Settings.get('reader/webRequest/helpTemplate'),
      data,
    );
  }

stream.once("open", fd => {
                            let cleaned = data.replace(/>/g, ">")
                            cleaned = cleaned.replace(/ {
                                stream.write(str)
                            })
                            stream.end()
                            fs.unlink(newpath, err => {
                                if (err) return logger.error(err)
                            });
                            logger.verbose(`New Paste: http://${req.headers.host}/${fileName} | IP: ${userIP}`)
                            let insecure = `http://${req.headers.host}/${fileName}`
                            let secure = `https://${req.headers.host}/${fileName}`
                            res.write(req.secure ? secure : insecure)
                            if (monitorChannel !== null) bot.createMessage(monitorChannel, `\`\`\`MARKDOWN\n[NEW PASTE]\n[IP](${userIP})\n\`\`\`\nhttp://${req.headers.host}/${fileName}`)
                            return res.end()
                        })

function renderContent(source, generator, context, options, cb) {
    ejs.renderFile(generator.templatePath(source), context, options, (err, res) => {
        if (!err) {
            cb(res);
        } else {
            generator.error(`Copying template ${source} failed. [${err}]`);
        }
    });
}

module.exports = function(template, data, done) {
    template = __dirname + "/../templates/" + template;
    ejs.renderFile(template, data, data, done);
};

return (req: any, res: any) =>
      ejs.renderFile(__dirname + "/../views/index.ejs", scope, {}, (err: any, str: string) => {
        if (err) {
          $log.error(err);
          res.status(500).send(err.message);
        } else {
          res.send(str);
        }
      });
  }

module.exports = function render(template, {
  props, data, computed, event,
}, cb) {
  ejs.renderFile(
    template,
    {
      renderType,
      props,
      data,
      computed,
      event,
    },
    cb,
  );
};