feat: review structure and questions for template

Author: peterpeterparker

src/index.ts

@@ -2,12 +2,7 @@ import {grey, red} from 'kleur';
 import {version} from '../package.json';
 import {installCliIfNecessary} from './services/cli.services';
 import {generate} from './services/generate.services';
-import {
-  promptDestination,
-  promptKind,
-  promptStarter,
-  promptTemplate
-} from './services/prompt.services';
+import {promptDestination, promptProjectKind, promptTemplate} from './services/prompt.services';
 import {checkNodeVersion} from './utils/env.utils';
 
 const JUNO_LOGO = `  __  __ __  __  _  ____ 
@@ -30,20 +25,13 @@ export const run = async () => {
 
   const {destination} = await promptDestination();
 
-  const {kind} = await promptKind();
+  const projectKind = await promptProjectKind();
 
-  if (kind === 'website') {
-    console.warn('🚧 This feature is not yet implemented. Please try again later.');
-    return;
-  }
-  const template = await promptTemplate(kind);
-  const starter = kind === 'app' ? await promptStarter() : null;
+  const template = await promptTemplate(projectKind);
 
   await generate({
-    kind,
     destination,
-    template,
-    starter
+    template
   });
 
   await installCliIfNecessary();

src/services/generate.services.ts

@@ -10,8 +10,7 @@ import {downloadFromURL} from '../utils/download.utils';
 import {
   createParentFolders,
   getLocalTemplatePath,
-  getRelativeTemplatePath,
-  getTemplateName
+  getRelativeTemplatePath
 } from '../utils/fs.utils';
 import {createDirectory, getLocalFiles, type LocalFileDescriptor} from '../utils/populate.utils';
 
@@ -43,8 +42,8 @@ export const populate = async (input: PopulateInput) => {
   }
 };
 
-const populateFromCDN = async ({where, ...rest}: PopulateInput) => {
-  const templatePath = getRelativeTemplatePath(rest);
+const populateFromCDN = async ({where, template}: PopulateInput) => {
+  const templatePath = getRelativeTemplatePath(template);
 
   const {hostname} = new URL(JUNO_CDN_URL);
 
@@ -62,7 +61,7 @@ const populateFromCDN = async ({where, ...rest}: PopulateInput) => {
 
   await createDirectory(where);
 
-  const templateName = getTemplateName(rest);
+  const {key: templateName} = template;
 
   const createFile = async ({name, content}: UntarOutputFile) => {
     const target = join(process.cwd(), where ?? '', name.replace(templateName, ''));
@@ -75,8 +74,8 @@ const populateFromCDN = async ({where, ...rest}: PopulateInput) => {
   await Promise.all(files.filter(({content}) => content.length !== 0).map(createFile));
 };
 
-const populateFromLocal = async ({where, ...rest}: PopulateInput) => {
-  const templatePath = getLocalTemplatePath(rest);
+const populateFromLocal = async ({where, template}: PopulateInput) => {
+  const templatePath = getLocalTemplatePath(template);
 
   const files = await getLocalFiles(templatePath);
 

src/services/prompt.services.ts

@@ -1,56 +1,72 @@
 import {isNullish} from '@junobuild/utils';
 import {red} from 'kleur';
 import prompts from 'prompts';
-import type {GeneratorInput} from '../types/generator';
+import {GeneratorInput, ProjectKind} from '../types/generator';
 import type {Template} from '../types/template';
 import {assertAnswerCtrlC} from '../utils/prompts.utils';
 
-const WEBSITE_TEMPLATES: Template[] = [];
+const WEBSITE_TEMPLATES: Template[] = [
+  {
+    framework: `Astro`,
+    key: `astro-starter`,
+    type: 'Starter',
+    description: 'Opt for a barebones scaffolding to kickstart your website'
+  }
+];
+
+const APP_TEMPLATES: Template[] = [
+  {
+    framework: `Next.js`,
+    key: `nextjs-starter`,
+    type: 'Starter',
+    description: 'Opt for a barebones scaffolding to kickstart your app'
+  }
+];
 
-const APP_TEMPLATES: Template[] = [{title: `Next.js`, key: `nextjs`}];
+export const promptTemplate = async (kind: ProjectKind): Promise<Template> => {
+  const allTemplates = Object.groupBy(
+    kind === 'app' ? APP_TEMPLATES : WEBSITE_TEMPLATES,
+    ({framework}) => framework
+  );
 
-export const promptTemplate = async (type: 'app' | 'website'): Promise<Template> => {
-  const collection = type === 'app' ? APP_TEMPLATES : WEBSITE_TEMPLATES;
+  const frameworks = Object.keys(allTemplates);
 
-  const {template}: {template: string} = await prompts({
+  const {framework}: Pick<Template, 'framework'> = await prompts({
     type: 'select',
-    name: 'template',
-    message: 'Which template do you want to use?',
-    choices: collection.map(({title, key}) => ({title, value: key}))
+    name: 'framework',
+    message: 'Which framework do you want to use?',
+    choices: frameworks.map((framework) => ({title: framework, value: framework}))
   });
 
-  assertAnswerCtrlC(template);
+  assertAnswerCtrlC(framework);
 
-  const item = collection.find(({key}) => key === template);
+  const templates = allTemplates[framework];
 
-  if (isNullish(item)) {
-    console.log(red(`Invalid ${type} template: ${template}`));
+  if (isNullish(templates) || templates.length === 0) {
+    console.log(`No template(s) found for ${red(framework)}. This is unexpected.`);
     process.exit(1);
   }
 
-  return item;
-};
+  if (templates.length === 1) {
+    return templates[0];
+  }
 
-export const promptStarter = async () => {
-  const {starter}: {starter: 'blank' | 'tutorial'} = await prompts({
+  const {template}: {template: Template | undefined} = await prompts({
     type: 'select',
-    name: 'starter',
-    message: 'Which starter template would you like to use?',
-    choices: [
-      {
-        title: 'Blank (A blank starter with "just" a customized index page)',
-        value: 'blank'
-      },
-      {
-        title: 'Tutorial (the "diary" example app)',
-        value: 'tutorial'
-      }
-    ]
+    name: 'template',
+    message: 'Choose your starting point?',
+    choices: templates.map((value) => ({
+      title: value.type,
+      description: value.description,
+      value
+    }))
   });
 
-  assertAnswerCtrlC(starter);
+  if (isNullish(template)) {
+    process.exit(1);
+  }
 
-  return starter;
+  return template;
 };
 
 export const promptDestination = async (): Promise<Pick<GeneratorInput, 'destination'>> => {
@@ -68,8 +84,8 @@ export const promptDestination = async (): Promise<Pick<GeneratorInput, 'destina
   return {destination};
 };
 
-export const promptKind = async (): Promise<Pick<GeneratorInput, 'kind'>> => {
-  const {kind}: Pick<GeneratorInput, 'kind'> = await prompts({
+export const promptProjectKind = async (): Promise<ProjectKind> => {
+  const {kind}: {kind: ProjectKind | undefined} = await prompts({
     type: 'select',
     name: 'kind',
     message: 'What kind of project are you starting?',
@@ -81,5 +97,5 @@ export const promptKind = async (): Promise<Pick<GeneratorInput, 'kind'>> => {
 
   assertAnswerCtrlC(kind);
 
-  return {kind};
+  return kind;
 };

src/types/generator.ts

@@ -1,8 +1,8 @@
-import type {Template, TemplateStarter} from './template';
+import {Template} from './template';
 
 export interface GeneratorInput {
-  kind: 'website' | 'app';
   destination: string | '';
   template: Template;
-  starter: TemplateStarter | null;
 }
+
+export type ProjectKind = 'website' | 'app';

src/types/template.ts

@@ -1,6 +1,10 @@
 export interface Template {
   key: string;
-  title: string;
+  framework: TemplateFramework;
+  type: TemplateType;
+  description: string;
 }
 
-export type TemplateStarter = 'blank' | 'tutorial';
+export type TemplateFramework = "Next.js" | "Astro"
+
+export type TemplateType = 'Starter' | 'Demo';

src/utils/fs.utils.ts

@@ -1,36 +1,16 @@
-import {nonNullish} from '@junobuild/utils';
 import {existsSync, lstatSync, mkdirSync, readdirSync} from 'node:fs';
 import {dirname, join} from 'node:path';
 import {fileURLToPath} from 'node:url';
-import type {GeneratorInput} from '../types/generator';
-import type {Template, TemplateStarter} from '../types/template';
+import type {Template} from '../types/template';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const TEMPLATE_PATH = 'templates';
 
-export const getTemplateName = ({
-  template: {key},
-  starter
-}: {
-  template: Template;
-  starter: TemplateStarter | null;
-}): string => `${key}${nonNullish(starter) ? `-${starter}` : ''}`;
+export const getRelativeTemplatePath = ({key}: Pick<Template, 'key'>) => join(TEMPLATE_PATH, key);
 
-export const getRelativeTemplatePath = (params: {
-  template: Template;
-  starter: TemplateStarter | null;
-}) => join(TEMPLATE_PATH, getTemplateName(params));
-
-export const getLocalTemplatePath = ({
-  kind,
-  ...rest
-}: {
-  template: Template;
-  starter: TemplateStarter | null;
-} & Pick<GeneratorInput, 'kind'>) =>
-  join(__dirname, '..', TEMPLATE_PATH, kind, getTemplateName(rest));
+export const getLocalTemplatePath = ({key}: Pick<Template, 'key'>) => join(__dirname, '..', TEMPLATE_PATH, key);
 
 export const createParentFolders = (target: string) => {
   const folder = dirname(target);