Refactor CLI import module helpers (#772)

This PR refactors some of the import module helpers.

Author: lorisleiva

packages/cli/src/commands/init.ts

@@ -203,7 +203,7 @@ async function isAnchorIdl(idlPath: string): Promise<boolean> {
     const resolvedIdlPath = resolveRelativePath(idlPath);
     if (!(await canRead(resolvedIdlPath))) return false;
     try {
-        const idlContent = await importModuleItem('IDL', resolvedIdlPath);
+        const idlContent = await importModuleItem({ identifier: 'IDL', from: resolvedIdlPath });
         return !isRootNode(idlContent);
     } catch {
         return false;

packages/cli/src/config.ts

@@ -28,7 +28,7 @@ export async function getConfig(options: Pick<ProgramOptions, 'config'>): Promis
         return [{}, configPath];
     }
 
-    const configFile = await importModuleItem('config file', configPath);
+    const configFile = await importModuleItem({ identifier: 'config file', from: configPath });
     if (!configFile || typeof configFile !== 'object') {
         throw new Error(`Invalid config file at "${configPath}"`);
     }

packages/cli/src/parsedConfig.ts

@@ -44,7 +44,7 @@ async function parseConfig(
     options: Pick<ProgramOptions, 'idl'>,
 ): Promise<ParsedConfig> {
     const idlPath = parseIdlPath(config, configPath, options);
-    const idlContent = await importModuleItem('IDL', idlPath);
+    const idlContent = await importModuleItem({ identifier: 'IDL', from: idlPath });
     const rootNode = await getRootNodeFromIdl(idlContent);
     const scripts = parseScripts(config.scripts ?? {}, configPath);
     const visitors = (config.before ?? []).map((v, i) => parseVisitorConfig(v, configPath, i, null));

packages/cli/src/utils/import.ts

@@ -2,80 +2,89 @@ import { createRequire } from 'node:module';
 
 import { canRead, isLocalModulePath, resolveRelativePath } from './fs';
 
-export async function importModuleItem<T = unknown>(
-    identifier: string,
-    modulePath: string,
-    itemName: string = 'default',
-): Promise<T> {
-    const module = await importModule(identifier, modulePath);
-    const item = pickModuleItem(module, itemName) as T | undefined;
-    if (item === undefined) {
-        throw new Error(`Failed to import "${itemName}" from ${identifier} at "${modulePath}".`);
+type ImportModuleItemOptions = {
+    from: string;
+    identifier?: string;
+    item?: string;
+};
+
+export async function importModuleItem<T = unknown>(options: ImportModuleItemOptions): Promise<T> {
+    const module = await importModule(options);
+    const moduleItem = pickModuleItem(module, options.item) as T | undefined;
+    if (moduleItem === undefined) {
+        const moduleInfo = getModuleInfo(options);
+        throw new Error(`Failed to ${moduleInfo}.`);
     }
-    return item;
+    return moduleItem;
 }
 
 type ModuleDefinition = Partial<Record<string, unknown>> & {
     __esModule?: boolean;
     default?: Partial<Record<string, unknown>> & { default?: Partial<Record<string, unknown>> };
 };
 
-function pickModuleItem(module: ModuleDefinition, itemName: string): unknown {
-    if (itemName === 'default') {
+function pickModuleItem(module: ModuleDefinition, item: string = 'default'): unknown {
+    if (item === 'default') {
         return module.default?.default ?? module.default ?? module;
     }
-    return module[itemName] ?? module.default?.[itemName] ?? module.default?.default?.[itemName];
+    return module[item] ?? module.default?.[item] ?? module.default?.default?.[item];
 }
 
-async function importModule<T extends object>(identifier: string, modulePath: string): Promise<T> {
-    if (isLocalModulePath(modulePath)) {
-        return await importLocalModule(identifier, modulePath);
+async function importModule<T extends object>(options: ImportModuleItemOptions): Promise<T> {
+    if (isLocalModulePath(options.from)) {
+        return await importLocalModule(options);
     }
 
     try {
-        return await importExternalUserModule(identifier, modulePath);
+        return await importExternalUserModule(options);
     } catch {
-        return await importExternalModule(identifier, modulePath);
+        return await importExternalModule(options);
     }
 }
 
-async function importLocalModule<T extends object>(identifier: string, modulePath: string): Promise<T> {
-    if (!(await canRead(modulePath))) {
-        throw new Error(`Cannot access ${identifier} at "${modulePath}"`);
+async function importLocalModule<T extends object>(options: ImportModuleItemOptions): Promise<T> {
+    const { identifier, from } = options;
+    if (!(await canRead(from))) {
+        throw new Error(`Cannot access ${identifier ?? 'module'} at "${from}"`);
     }
 
-    const dotIndex = modulePath.lastIndexOf('.');
-    const extension = dotIndex === -1 ? undefined : modulePath.slice(dotIndex);
-    const modulePromise = extension === '.json' ? import(modulePath, { with: { type: 'json' } }) : import(modulePath);
-    return await handleImportPromise(modulePromise, identifier, modulePath);
+    const dotIndex = from.lastIndexOf('.');
+    const extension = dotIndex === -1 ? undefined : from.slice(dotIndex);
+    const modulePromise = extension === '.json' ? import(from, { with: { type: 'json' } }) : import(from);
+    return await handleImportPromise(modulePromise, options);
 }
 
-async function importExternalModule<T extends object>(identifier: string, modulePath: string): Promise<T> {
-    return await handleImportPromise(import(modulePath), identifier, modulePath);
+async function importExternalModule<T extends object>(options: ImportModuleItemOptions): Promise<T> {
+    return await handleImportPromise(import(options.from), options);
 }
 
-async function importExternalUserModule<T extends object>(identifier: string, modulePath: string): Promise<T> {
+async function importExternalUserModule<T extends object>(options: ImportModuleItemOptions): Promise<T> {
     const userPackageJsonPath = resolveRelativePath('package.json');
     const userRequire = createRequire(userPackageJsonPath);
-    const userModulePath = userRequire.resolve(modulePath);
-    return await importExternalModule<T>(identifier, userModulePath);
+    const userFrom = userRequire.resolve(options.from);
+    return await importExternalModule<T>({ ...options, from: userFrom });
 }
 
 async function handleImportPromise<T extends object>(
     importPromise: Promise<unknown>,
-    identifier: string,
-    modulePath: string,
+    options: ImportModuleItemOptions,
 ): Promise<T> {
     try {
         return (await importPromise) as T;
     } catch (error) {
+        const moduleInfo = getModuleInfo(options);
         let causeMessage =
             !!error && typeof error === 'object' && 'message' in error && typeof error.message === 'string'
                 ? (error as { message: string }).message
                 : undefined;
-        causeMessage = causeMessage ? ` (caused by: ${causeMessage})` : '';
-        throw new Error(`Failed to import ${identifier} at "${modulePath}" as a module${causeMessage}`, {
-            cause: error,
-        });
+        causeMessage = causeMessage ? `\n(caused by: ${causeMessage})` : '';
+        throw new Error(`Failed to ${moduleInfo}.${causeMessage}`, { cause: error });
     }
 }
+
+function getModuleInfo(options: ImportModuleItemOptions): string {
+    const { identifier, from, item } = options;
+    const importStatement = item ? `import { ${item} } from '${from}'` : `import default from '${from}'`;
+    if (!identifier) return importStatement;
+    return `import ${identifier} [${importStatement}]`;
+}

packages/cli/src/utils/nodes.ts

@@ -19,11 +19,10 @@ export async function getRootNodeFromIdl(idl: unknown): Promise<RootNode> {
         throw new Error('Cannot proceed without Anchor IDL support. Install cancelled by user.');
     }
 
-    const rootNodeFromAnchor = await importModuleItem<(idl: unknown) => RootNode>(
-        'Anchor adapter',
-        '@codama/nodes-from-anchor',
-        'rootNodeFromAnchor',
-    );
+    const rootNodeFromAnchor = await importModuleItem<(idl: unknown) => RootNode>({
+        from: '@codama/nodes-from-anchor',
+        item: 'rootNodeFromAnchor',
+    });
     return rootNodeFromAnchor(idl);
 }
 

packages/cli/src/utils/visitors.ts

@@ -15,7 +15,7 @@ export async function getRootNodeVisitors(
 async function getRootNodeVisitor(visitorConfig: ParsedVisitorConfig): Promise<Visitor<RootNode, 'rootNode'>> {
     const { args, item, path } = visitorConfig;
     const identifier = getVisitorIdentifier(visitorConfig);
-    const moduleItem = await importModuleItem(identifier, path, item);
+    const moduleItem = await importModuleItem({ identifier, from: path, item });
     const visitor = await getVisitorFromModuleItem(identifier, moduleItem, args);
     return rootNodeVisitor(root => {
         const result = visit(root, visitor);