ESM/节点的正确导入/导出和绑定

Question

I have some pre-ES6 code that was working fine with require-type syntax, and am trying to port this to ESM friendly methodology. I have much of the js to mjs coding ported, and am working on a dynamic file loading block, that is giving me fits. I've gotten through enough googling and debugging to realize my issue is now with the syntax of the export function in the "events" file, which I'm using default syntax to support.

First the calling file:

async function eventLoad(eventDir = './events/')
    {
        await fs.readdir(`./events/`,function (err, files){
            if (err)
            {
                console.error(`${error}: Error loading event: ${err}`);
                return;
            }
            else
            {
                const events = files.filter(file=>file.endsWith('.mjs'));
                for( const file of events)
                {
                    console.log(`event file name is ${file}`);
                    const {default: event} = import(join(`./events/`,`${file}`));
                    const eventName = file.split('.')[0];
                    dBot.on(eventName, event.bind(null,dBot));
                    console.log(`${success} Loaded event ${eventName}`);
                }
            }
        })
    }
    eventLoad();
// please ignore the missing promise on the import...I'll be adding it shortly. :)

I get an error: TypeError: Cannot read property 'bind' of undefined

my export in the other file declares like this:

export default async (client, message) =>
{
...

knowing from googled issues that much of the likelihood rests in the improper definition in the file that is exporting the fuction, I tried playing with the syntax:

async function ProcessMessages (client, message)
{
...
}
export {ProcessMessages as default };

but alas, no help. I'm sure the issue is properly handling the export syntax, but I'm learning this as I go, and would appreciate any help you could provide, thanks!!!

Update: (based on solution, here is my code changes in case anyone else wants to leverage)

async function eventLoad(eventDir = './events/')
{
    let files;
    try {
        files = await promiseBasedReaddir(`${eventDir}`);
    }
    catch (err) {
        console.error(`${error}: Error loading event: ${err}`);
        return;
    }
    const events = files.filter(file=>file.endsWith('.mjs'));
    for( const file of events)
    {
        console.log(`event file name is ${file}`);
        import(`${eventDir}${file}`)
        .then(function( {default: event} ){
            const eventName = file.split('.')[0];
            dBot.on(eventName, event.bind(null,dBot));
            console.log(`${success} Loaded event ${eventName}`);
        })
        .catch(function(err){
            console.error(`${error}: Error loading event: ${err}`);
            return;
        })

    }
}
eventLoad();

Answer 1

On this line, you do a dynamic import:

const {default: event} = import(join(`./events/`,`${file}`));

import will always return a Promise. The Promise object doesn't have a .bind method, only functions do. You need to await or .then() import() 's return value. So you can't "ignore the missing promise on the import".

A second issue:

 await fs.readdir(`./events/`, ...´

fs.readdir doesn't return a promise, so await -ing it is useless. It is functionally the same as await undefined; . The outer function will return before the callback has finished.

If you use a readdir function that returns a promise, you can simplify things a lot.

    import { promises as fsPromises } from 'fs';
    const { readdir: promiseBasedReaddir } = fsPromises;

    // OR alternatively:
    import { readdir } from 'fs';
    import { promisify} from 'util';
    const promiseBasedReaddir = promisify(readdir);

    async function eventLoad(eventDir = './events/')
    {
        let files;
        try {
            files = await promiseBasedReaddir(`./events/`);
        } catch (err) {
            console.error(`${error}: Error loading event: ${err}`);
            return;
        }
        
        const events = files.filter(file=>file.endsWith('.mjs'));
        for( const file of events)
        {
            console.log(`event file name is ${file}`);
            const {default: event} = await import(join(`./events/`,`${file}`));
            const eventName = file.split('.')[0];
            dBot.on(eventName, event.bind(null,dBot));
            console.log(`${success} Loaded event ${eventName}`);
        }
    }

Promisify will transform a callback-using function to a promise-returning function. The fs module has promise-based functions, so you don't need to use Promisify if you just import those.