feat(cli): show template sources when initializing

Author: erickzhao

packages/api/core/spec/fast/find-template.spec.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 
-import { describe, expect, it, vi } from 'vitest';
+import globalDirs from 'global-dirs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { findTemplate } from '../../src/api/init-scripts/find-template';
 
@@ -14,14 +15,20 @@ describe('findTemplate', () => {
    * for the fixtures to be installed in your local `node_modules`.
    */
   describe('local modules', () => {
-    it('should find an @electron-forge/template based on name', async () => {
-      await expect(findTemplate('fixture')).resolves.toEqual({ name: 'electron-forge-template-fixture' });
+    it('should find an @electron-forge/template based on partial name', async () => {
+      await expect(findTemplate('fixture')).resolves.toEqual(expect.objectContaining({ name: '@electron-forge/template-fixture' }));
     });
-    it('should find an @electron-forge/template based on name', async () => {
-      await expect(findTemplate('fixture-two')).resolves.toEqual({ name: 'electron-forge-template-fixture' });
+
+    it('should find an @electron-forge/template based on full name', async () => {
+      await expect(findTemplate('@electron-forge/template-fixture')).resolves.toEqual(expect.objectContaining({ name: '@electron-forge/template-fixture' }));
     });
-    it('should find an @electron-forge/template based on name', async () => {
-      await expect(findTemplate('electron-forge-template-fixture-two')).resolves.toEqual({ name: 'electron-forge-template-fixture' });
+    it('should find an electron-forge-template based on partial name', async () => {
+      await expect(findTemplate('fixture-two')).resolves.toEqual(expect.objectContaining({ name: 'electron-forge-template-fixture' }));
+    });
+    it('should find an @electron-forge-template based on full name', async () => {
+      await expect(findTemplate('electron-forge-template-fixture-two')).resolves.toEqual(
+        expect.objectContaining({ name: 'electron-forge-template-fixture-two' })
+      );
     });
   });
 
@@ -31,23 +38,22 @@ describe('findTemplate', () => {
    * `node_modules` in order for the `require.resolve` custom path to work.
    */
   describe('global modules', () => {
-    vi.mock(import('global-dirs'), async (importOriginal) => {
-      const mod = await importOriginal();
-      return {
-        default: {
-          ...mod.default,
-          npm: {
-            ...mod.default.npm,
-            packages: path.resolve(__dirname, '..', 'fixture', 'global-stub', 'node_modules'),
-          },
-        },
-      };
+    beforeEach(() => {
+      vi.spyOn(globalDirs, 'npm', 'get').mockReturnValue({
+        binaries: '',
+        prefix: '',
+        packages: path.resolve(__dirname, '..', 'fixture', 'global-stub', 'node_modules'),
+      });
     });
     it('should find an @electron-forge/template based on name', async () => {
-      await expect(findTemplate('global')).resolves.toEqual({ name: 'electron-forge-template-fixture-global' });
+      await expect(findTemplate('global')).resolves.toEqual(
+        expect.objectContaining({ template: { name: 'electron-forge-template-fixture-global' }, type: 'global' })
+      );
     });
     it('should find an electron-forge-template based on name', async () => {
-      await expect(findTemplate('global-two')).resolves.toEqual({ name: 'electron-forge-template-fixture-global' });
+      await expect(findTemplate('global-two')).resolves.toEqual(
+        expect.objectContaining({ template: { name: 'electron-forge-template-fixture-global' }, type: 'global' })
+      );
     });
   });
 

packages/api/core/src/api/init-scripts/find-template.ts

@@ -11,40 +11,56 @@ enum TemplateType {
   local = 'local',
 }
 
-export const findTemplate = async (template: string): Promise<ForgeTemplate> => {
-  let templateModulePath!: string;
+export interface ForgeTemplateDetails {
+  name: string;
+  path: string;
+  template: ForgeTemplate;
+  type: TemplateType;
+}
+
+export const findTemplate = async (template: string): Promise<ForgeTemplateDetails> => {
+  let foundTemplate: Omit<ForgeTemplateDetails, 'template'> | null = null;
+
   const resolveTemplateTypes = [
     [TemplateType.global, `electron-forge-template-${template}`],
     [TemplateType.global, `@electron-forge/template-${template}`],
     [TemplateType.local, `electron-forge-template-${template}`],
     [TemplateType.local, `@electron-forge/template-${template}`],
     [TemplateType.global, template],
     [TemplateType.local, template],
-  ];
-  let foundTemplate = false;
+  ] as const;
   for (const [templateType, moduleName] of resolveTemplateTypes) {
     try {
       d(`Trying ${templateType} template: ${moduleName}`);
+      let templateModulePath: string;
       if (templateType === TemplateType.global) {
         templateModulePath = require.resolve(moduleName, {
           paths: [globalDirs.npm.packages, globalDirs.yarn.packages],
         });
       } else {
         templateModulePath = require.resolve(moduleName);
       }
-      foundTemplate = true;
+      foundTemplate = {
+        path: templateModulePath,
+        type: templateType,
+        name: moduleName,
+      };
       break;
     } catch (err) {
       d(`Error: ${err instanceof Error ? err.message : err}`);
     }
   }
   if (!foundTemplate) {
     throw new Error(`Failed to locate custom template: "${template}".`);
-  }
-
-  d(`found template module at: ${templateModulePath}`);
+  } else {
+    d(`found template module at: ${foundTemplate.path}`);
 
-  const templateModule: PossibleModule<ForgeTemplate> = await import(templateModulePath);
+    const templateModule: PossibleModule<ForgeTemplate> = await import(foundTemplate.path);
+    const tmpl = templateModule.default ?? templateModule;
 
-  return templateModule.default ?? templateModule;
+    return {
+      ...foundTemplate,
+      template: tmpl,
+    };
+  }
 };

packages/api/core/src/api/init.ts

@@ -81,10 +81,13 @@ export default async ({
         },
       },
       {
-        title: `Locating custom template: "${template}"`,
-        task: async (ctx) => {
-          ctx.templateModule = await findTemplate(template);
+        title: `Resolving template: ${chalk.cyan(template)}`,
+        task: async (ctx, task) => {
+          const tmpl = await findTemplate(template);
+          ctx.templateModule = tmpl.template;
+          task.output = `Using ${chalk.green(tmpl.name)} (${tmpl.type} module)`;
         },
+        rendererOptions: { persistentOutput: true },
       },
       {
         title: 'Initializing directory',