chore: refactor toolchains

Author: jherr

packages/cta-cli/src/cli.ts

@@ -4,7 +4,6 @@ import chalk from 'chalk'
 
 import {
   SUPPORTED_PACKAGE_MANAGERS,
-  SUPPORTED_TOOLCHAINS,
   getAllAddOns,
   getFrameworkById,
   getFrameworkByName,
@@ -66,6 +65,15 @@ export function cli({
 
   const availableFrameworks = getFrameworks().map((f) => f.name)
 
+  const toolchains = new Set<string>()
+  for (const framework of getFrameworks()) {
+    for (const addOn of framework.getAddOns()) {
+      if (addOn.type === 'toolchain') {
+        toolchains.add(addOn.id)
+      }
+    }
+  }
+
   program.name(name).description(`CLI to create a new ${appName} application`)
 
   program
@@ -157,14 +165,14 @@ export function cli({
       },
     )
     .option<ToolChain>(
-      `--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`,
+      `--toolchain <${Array.from(toolchains).join('|')}>`,
       `Explicitly tell the CLI to use this toolchain`,
       (value) => {
-        if (!SUPPORTED_TOOLCHAINS.includes(value as ToolChain)) {
+        if (!toolchains.has(value as ToolChain)) {
           throw new InvalidArgumentError(
-            `Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.join(
-              ', ',
-            )}`,
+            `Invalid toolchain: ${value}. The following are allowed: ${Array.from(
+              toolchains,
+            ).join(', ')}`,
           )
         }
         return value as ToolChain

packages/cta-cli/src/options.ts

@@ -10,10 +10,8 @@ import {
 import {
   CODE_ROUTER,
   DEFAULT_PACKAGE_MANAGER,
-  DEFAULT_TOOLCHAIN,
   FILE_ROUTER,
   SUPPORTED_PACKAGE_MANAGERS,
-  SUPPORTED_TOOLCHAINS,
   finalizeAddOns,
   getAllAddOns,
   getFrameworkById,
@@ -78,7 +76,8 @@ export async function normalizeOptions(
     if (
       Array.isArray(cliOptions.addOns) ||
       starter?.dependsOn ||
-      forcedAddOns
+      forcedAddOns ||
+      cliOptions.toolchain
     ) {
       addOns = true
       let finalAddOns = Array.from(
@@ -94,6 +93,11 @@ export async function normalizeOptions(
         )
       }
       const framework = getFrameworkById(cliOptions.framework || 'react-cra')!
+
+      if (cliOptions.toolchain) {
+        finalAddOns.push(cliOptions.toolchain)
+      }
+
       chosenAddOns = await finalizeAddOns(
         framework,
         forcedMode || cliOptions.template === 'file-router'
@@ -115,7 +119,6 @@ export async function normalizeOptions(
         cliOptions.packageManager ||
         getPackageManager() ||
         DEFAULT_PACKAGE_MANAGER,
-      toolchain: cliOptions.toolchain || DEFAULT_TOOLCHAIN,
       mode,
       git: !!cliOptions.git,
       addOns,
@@ -297,30 +300,50 @@ export async function promptForOptions(
   }
 
   // Toolchain selection
+  let toolchain: AddOn | undefined = undefined
   if (cliOptions.toolchain === undefined) {
-    const tc = await select({
+    const toolchains = new Set<AddOn>()
+    for (const addOn of framework.getAddOns()) {
+      if (addOn.type === 'toolchain') {
+        toolchains.add(addOn)
+      }
+    }
+
+    const tc = await select<AddOn | undefined>({
       message: 'Select toolchain',
-      options: SUPPORTED_TOOLCHAINS.map((tc) => ({
-        value: tc,
-        label: tc,
-      })),
-      initialValue: DEFAULT_TOOLCHAIN,
+      options: [
+        {
+          value: undefined,
+          label: 'None',
+        },
+        ...Array.from(toolchains).map((tc) => ({
+          value: tc,
+          label: tc.name,
+        })),
+      ],
+      initialValue: undefined,
     })
     if (isCancel(tc)) {
       cancel('Operation cancelled.')
       process.exit(0)
     }
-    options.toolchain = tc
+    toolchain = tc
   } else {
-    options.toolchain = cliOptions.toolchain
+    for (const addOn of framework.getAddOns()) {
+      if (addOn.type === 'toolchain' && addOn.id === cliOptions.toolchain) {
+        toolchain = addOn
+      }
+    }
   }
 
-  options.chosenAddOns = []
+  options.chosenAddOns = toolchain ? [toolchain] : []
   if (Array.isArray(cliOptions.addOns)) {
     options.chosenAddOns = await finalizeAddOns(
       options.framework,
       options.mode,
-      Array.from(new Set([...cliOptions.addOns, ...forcedAddOns])),
+      Array.from(
+        new Set([...cliOptions.addOns, ...forcedAddOns, toolchain?.id]),
+      ).filter(Boolean) as Array<string>,
     )
     options.tailwind = true
   } else if (cliOptions.addOns) {
@@ -374,22 +397,30 @@ export async function promptForOptions(
     if (
       selectedAddOns.length > 0 ||
       selectedExamples.length > 0 ||
-      forcedAddOns.length > 0
+      forcedAddOns.length > 0 ||
+      toolchain
     ) {
       options.chosenAddOns = await finalizeAddOns(
         options.framework,
         options.mode,
         Array.from(
-          new Set([...selectedAddOns, ...selectedExamples, ...forcedAddOns]),
-        ),
+          new Set([
+            ...selectedAddOns,
+            ...selectedExamples,
+            ...forcedAddOns,
+            toolchain?.id,
+          ]),
+        ).filter(Boolean) as Array<string>,
       )
       options.tailwind = true
     }
   } else if (forcedAddOns.length > 0) {
     options.chosenAddOns = await finalizeAddOns(
       options.framework,
       options.mode,
-      forcedAddOns,
+      Array.from(new Set([...forcedAddOns, toolchain?.id])).filter(
+        Boolean,
+      ) as Array<string>,
     )
   }
 

packages/cta-cli/src/types.ts

@@ -1,15 +1,11 @@
-import type {
-  PackageManager,
-  TemplateOptions,
-  ToolChain,
-} from '@tanstack/cta-core'
+import type { PackageManager, TemplateOptions } from '@tanstack/cta-core'
 
 export interface CliOptions {
   template?: TemplateOptions
   framework?: string
   tailwind?: boolean
   packageManager?: PackageManager
-  toolchain?: ToolChain
+  toolchain?: string
   projectName?: string
   git?: boolean
   addOns?: Array<string> | boolean

packages/cta-core/src/add-ons.ts

@@ -1,91 +1,21 @@
-import { readFile } from 'node:fs/promises'
-import { existsSync, readdirSync } from 'node:fs'
-import { resolve } from 'node:path'
+import type { AddOn, Framework } from './types.js'
 
-import { readFileHelper } from './file-helper.js'
-import { findFilesRecursively, isDirectory } from './utils.js'
-
-import type { AddOn, FrameworkDefinition } from './types.js'
-
-export async function getAllAddOns(
-  framework: FrameworkDefinition,
+export function getAllAddOns(
+  framework: Framework,
   template: string,
-): Promise<Array<AddOn>> {
-  const addOns: Array<AddOn> = []
-
-  for (const type of ['add-on', 'example']) {
-    const addOnsBase = framework.addOnsDirectory
-
-    if (!existsSync(addOnsBase)) {
-      continue
-    }
-
-    for (const dir of await readdirSync(addOnsBase).filter((file) =>
-      isDirectory(resolve(addOnsBase, file)),
-    )) {
-      const filePath = resolve(addOnsBase, dir, 'info.json')
-      const fileContent = await readFile(filePath, 'utf-8')
-      const info = JSON.parse(fileContent)
-
-      if (!info.templates.includes(template)) {
-        continue
-      }
-
-      let packageAdditions: Record<string, string> = {}
-      if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
-        packageAdditions = JSON.parse(
-          await readFile(resolve(addOnsBase, dir, 'package.json'), 'utf-8'),
-        )
-      }
-
-      let readme: string | undefined
-      if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
-        readme = await readFile(resolve(addOnsBase, dir, 'README.md'), 'utf-8')
-      }
-
-      const absoluteFiles: Record<string, string> = {}
-      const assetsDir = resolve(addOnsBase, dir, 'assets')
-      if (existsSync(assetsDir)) {
-        await findFilesRecursively(assetsDir, absoluteFiles)
-      }
-      const files: Record<string, string> = {}
-      for (const file of Object.keys(absoluteFiles)) {
-        files[file.replace(assetsDir, '.')] = await readFileHelper(file)
-      }
-
-      const getFiles = () => {
-        return Promise.resolve(Object.keys(files))
-      }
-      const getFileContents = (path: string) => {
-        return Promise.resolve(files[path])
-      }
-
-      addOns.push({
-        ...info,
-        id: dir,
-        type,
-        packageAdditions,
-        readme,
-        files,
-        deletedFiles: [],
-        getFiles,
-        getFileContents,
-      })
-    }
-  }
-
-  return addOns
+): Array<AddOn> {
+  return framework.getAddOns().filter((a) => a.templates.includes(template))
 }
 
 // Turn the list of chosen add-on IDs into a final list of add-ons by resolving dependencies
 export async function finalizeAddOns(
-  framework: FrameworkDefinition,
+  framework: Framework,
   template: string,
   chosenAddOnIDs: Array<string>,
 ): Promise<Array<AddOn>> {
   const finalAddOnIDs = new Set(chosenAddOnIDs)
 
-  const addOns = await getAllAddOns(framework, template)
+  const addOns = getAllAddOns(framework, template)
 
   for (const addOnID of finalAddOnIDs) {
     let addOn: AddOn | undefined
@@ -111,6 +41,7 @@ export async function finalizeAddOns(
   const finalAddOns = [...finalAddOnIDs].map(
     (id) => addOns.find((a) => a.id === id)!,
   )
+
   return finalAddOns
 }
 

packages/cta-core/src/config-file.ts

@@ -39,6 +39,9 @@ export async function readConfigFile(
   try {
     const configFile = resolve(targetDir, CONFIG_FILE)
     const config = await readFile(configFile, 'utf8')
+
+    // TODO: Look for old config files and convert them to the new format
+
     return JSON.parse(config)
   } catch {
     return null