Support string types in dynamic import types.

Search Terms

dynamic import type

Suggestion

I'd like to define a function that wraps a dynamic require or import. Specifically, I'm writing a library that uses node's worker_thread and I want to support 'dependency injection' via dynamic import. You can't pass class instances or functions across execution contexts.

import { isMainThread, Worker, workerData } from 'worker_threads';

export type LoggerImportPath = ???;

export default function lib(logger: LoggerImportPath): Worker {
  return new Worker(__filename, { workerData: { logger });
}

if (!isMainThread) {
  const module: { default: Logger } = await import(workerData.logger);
}

// no type error, ./path/to/logger exports a Logger.
lib(`${__filename}/path/to/logger');

// this should be a type error: import('not-a-module') is not assignable to { default: Logger };
lib('not-a-module');

I don't think you can currently define LoggerImportPath any more precisely than string and import(path: string) returns Promise<any>.

// this returns `{ default: Logger}`
await import('path');

// this returns `any`
const wrapper = path => import(path);
const module: any = await wrapper('path')

Use Cases

I haven't seen this pattern in any other libraries, but I think it's a good way to pass classes or functions across threads or execution contexts. You can't currently limit the kinds of strings that library uses can pass when a module path is expected.

Examples

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

No repository files, tests, or entry points are named. Start by reproducing the literal dynamic import and string-parameter wrapper examples in a TypeScript project, then trace the existing type-checking behavior for each. Done means the requested string-based import type is specified and covered by tests, including both the valid logger path and invalid module path cases.