Import all modules from folder without know the names (nodejs) - node.js

Question

I'd like to know if is there any way or library available to import all modules from a folder without know the names.
Example:
└── routes/
└──── x.routes.ts
└──── y.routes.ts
└──── z.routes.ts
└──── ...
Then makes those available from mymodule.ts for example.

Answer 1

Unfortunately, import works only with explicit paths.
But webpack provides the following feature:
https://webpack.js.org/guides/dependency-management/#context-module-api

Answer 2

I was able to do reading the files path from a folder with fs.readDirSync()
Then importing them like:
const { default: Module } = require( _module.path ) (modules that was exported by default) all into an iterator.
I share my entire solution:
This abstracted function returns all modules paths in a directory based on a dir, a criteria for get them and an exclude list of filenames:
export const getModules = ( params: IM ): IModule[] => {
const { dir, criteria, excludeList } = params
let { modulesList=[] } = params
const modulePrefix: string = getModulePrefix() // includes slash
const modulesDir: string = path.resolve( `${modulePrefix}${dir}` )
const modules: string[] = fs.readdirSync( modulesDir )
const r: RegExp[] = ( process.platform === 'win32' ) ? [/\\\w+$/, /^\\/] : [/\/\w+$/, /^\//]
modules.forEach(( _module: string ) => {
const modulePath: string = path.resolve( modulesDir, _module )
if ( fs.statSync(modulePath).isDirectory() ) {
// Recursive call
modulesList = getModules({ dir:modulePath, criteria, excludeList, modulesList })
} else if ( criteria.test(_module) && !excludeList.includes(_module) ) {
modulesList.push({
path: modulePath,
filename: _module,
type: modulesDir.match(r[0])![0].replace(r[1], '')
})
}
})
return modulesList
}
The IM params types:
interface IM {
readonly dir: string
readonly criteria: RegExp
readonly excludeList: string[]
modulesList?: IModule[]
}
This is a cross-platform one. It will works on unix and windows based systems.
The modules types returned are described by:
export interface IModule {
path: string
filename: string
type: string
}
And the function above is used by other functions (not abstracted) that get those module paths based in some rules as follows (in this case, for middlewares types in middlewares folder):
export const getMiddlewares = (): IModule[] => {
const dir: string = './src/middlewares'
const criteria: RegExp = /^.+\.(ts|js)$/
const excludeList: string[] = [
'tmpl.ts',
'tmpl.js'
]
return getModules({ dir, criteria, excludeList })
}
Then modules can be imported as resources like (I have this in another function called loadResources()):
// modulePaths has IModule[] as a type
modulePaths.forEach(( _module: IModule ) => {
const { default: Module } = require( _module.path )
if ( Module instanceof Function ) {
const $resource: Resource = Module( service )
if ( callback instanceof Function )
callback( $resource )
;
} else {
console.warn( chalk.yellow(
`WARNING: #${_module.type} ‚Üí ${_module.filename.replace(/\.(ts|js)$/, '')} must export a function by default`
))
}
})
I Hope to help to any one else who is searching for this solution.
The getModules() function is re-usable and it is abstracted to import any thing you want based on your own rules.
Source code can be reviewed in my repository: https://github.com/bananasplit-js/bananasplit-js/blob/65d7cdd9dca4c89f8f32a7ae13c63ed098dab7c2/src/providers/core/helpers/resources.ts#L43