chore: first pass at remote handling

jherr · jherr · commit df24f72ac640 · 2025-03-23T08:43:35.000-07:00
diff --git a/src/add-ons.ts b/src/add-ons.ts
@@ -1,66 +1,26 @@
 import { readFile } from 'node:fs/promises'
-import { existsSync, readdirSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import chalk from 'chalk'
 
 import { DEFAULT_FRAMEWORK } from './constants.js'
-import type { CliOptions, Framework } from './types.js'
+import type { AddOn, CliOptions, Framework } from './types.js'
 
-type BooleanVariable = {
-  name: string
-  default: boolean
-  description: string
-  type: 'boolean'
-}
-
-type NumberVariable = {
-  name: string
-  default: number
-  description: string
-  type: 'number'
-}
-
-type StringVariable = {
-  name: string
-  default: string
-  description: string
-  type: 'string'
+function isDirectory(path: string): boolean {
+  return statSync(path).isDirectory()
 }
 
-export type Variable = BooleanVariable | NumberVariable | StringVariable
-
-export type AddOn = {
-  id: string
-  type: 'add-on' | 'example'
-  name: string
-  description: string
-  link: string
-  templates: Array<string>
-  routes: Array<{
-    url: string
-    name: string
-  }>
-  directory: string
-  packageAdditions: {
-    dependencies?: Record<string, string>
-    devDependencies?: Record<string, string>
-    scripts?: Record<string, string>
-  }
-  command?: {
-    command: string
-    args?: Array<string>
+function findFilesRecursively(path: string, files: Record<string, string>) {
+  const dirFiles = readdirSync(path)
+  for (const file of dirFiles) {
+    const filePath = resolve(path, file)
+    if (isDirectory(filePath)) {
+      findFilesRecursively(filePath, files)
+    } else {
+      files[filePath] = readFileSync(filePath, 'utf-8').toString()
+    }
   }
-  readme?: string
-  phase: 'setup' | 'add-on'
-  shadcnComponents?: Array<string>
-  warning?: string
-  dependsOn?: Array<string>
-  variables?: Array<Variable>
-}
-
-function isDirectory(path: string): boolean {
-  return statSync(path).isDirectory()
 }
 
 export async function getAllAddOns(
@@ -101,13 +61,24 @@ export async function getAllAddOns(
         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, '.')] = absoluteFiles[file]
+      }
+
       addOns.push({
         ...info,
         id: dir,
         type,
-        directory: resolve(addOnsBase, dir),
         packageAdditions,
         readme,
+        files,
+        deletedFiles: [],
       })
     }
   }
@@ -126,8 +97,13 @@ export async function finalizeAddOns(
   const addOns = await getAllAddOns(framework, template)
 
   for (const addOnID of finalAddOnIDs) {
-    const addOn = addOns.find((a) => a.id === addOnID)
-    if (!addOn) {
+    let addOn: AddOn | undefined
+    const localAddOn = addOns.find((a) => a.id === addOnID)
+    if (localAddOn) {
+      addOn = localAddOn
+    } else if (addOnID.startsWith('http')) {
+      addOn = await loadRemoteAddOn(addOnID)
+    } else {
       throw new Error(`Add-on ${addOnID} not found`)
     }
 
@@ -154,3 +130,14 @@ export async function listAddOns(options: CliOptions) {
     console.log(`${chalk.bold(addOn.id)}: ${addOn.description}`)
   }
 }
+
+function loadAddOn(path: string): AddOn {
+  const fileContent = await readFile(path, 'utf-8')
+  return JSON.parse(fileContent)
+}
+
+async function loadRemoteAddOn(url: string): AddOn {
+  const response = await fetch(url)
+  const fileContent = await response.json()
+  return JSON.parse(fileContent)
+}
diff --git a/src/create-app.ts b/src/create-app.ts
@@ -10,8 +10,7 @@ import { sortObject } from './utils.js'
 import { writeConfigFile } from './config-file.js'
 import { packageManagerExecute } from './package-manager.js'
 
-import type { Environment } from './environment.js'
-import type { Options } from './types.js'
+import type { Environment, Options } from './types.js'
 
 function createCopyFiles(environment: Environment, targetDir: string) {
   return async function copyFiles(
@@ -48,8 +47,8 @@ function createTemplateFile(
   targetDir: string,
 ) {
   return async function templateFile(
-    templateDir: string,
     file: string,
+    content: string,
     targetFileName?: string,
     extraTemplateValues?: Record<string, any>,
   ) {
@@ -116,13 +115,8 @@ function createTemplateFile(
       getPackageManagerRunScript,
     }
 
-    const template = await environment.readFile(
-      resolve(templateDir, file),
-      'utf-8',
-    )
-    let content = ''
     try {
-      content = render(template, templateValues)
+      content = render(content, templateValues)
     } catch (error) {
       console.error(chalk.red(`EJS error in file ${file}`))
       console.error(error)
@@ -253,50 +247,33 @@ async function createPackageJSON(
   )
 }
 
-async function copyFilesRecursively(
+async function copyAddOnFile(
   environment: Environment,
-  source: string,
+  content: string,
   target: string,
-  templateFile: (file: string, targetFileName?: string) => Promise<void>,
+  templateFile: (content: string, targetFileName: string) => Promise<void>,
 ) {
-  if (environment.isDirectory(source)) {
-    const files = environment.readdir(source)
-    for (const file of files) {
-      const sourceChild = resolve(source, file)
-      const targetChild = resolve(target, file)
-      await copyFilesRecursively(
-        environment,
-        sourceChild,
-        targetChild,
-        templateFile,
-      )
-    }
-  } else {
-    let targetFile = basename(target).replace(/_dot_/, '.')
-    let isTemplate = false
-    if (targetFile.endsWith('.ejs')) {
-      targetFile = targetFile.replace('.ejs', '')
-      isTemplate = true
-    }
-    let isAppend = false
-    if (targetFile.endsWith('.append')) {
-      targetFile = targetFile.replace('.append', '')
-      isAppend = true
-    }
+  let targetFile = basename(target).replace(/_dot_/, '.')
+  let isTemplate = false
+  if (targetFile.endsWith('.ejs')) {
+    targetFile = targetFile.replace('.ejs', '')
+    isTemplate = true
+  }
+  let isAppend = false
+  if (targetFile.endsWith('.append')) {
+    targetFile = targetFile.replace('.append', '')
+    isAppend = true
+  }
 
-    const targetPath = resolve(dirname(target), targetFile)
+  const targetPath = resolve(dirname(target), targetFile)
 
-    if (isTemplate) {
-      await templateFile(source, targetPath)
+  if (isTemplate) {
+    await templateFile(content, targetPath)
+  } else {
+    if (isAppend) {
+      await environment.appendFile(targetPath, content)
     } else {
-      if (isAppend) {
-        await environment.appendFile(
-          targetPath,
-          (await environment.readFile(source)).toString(),
-        )
-      } else {
-        await environment.copyFile(source, targetPath)
-      }
+      await environment.writeFile(targetPath, content)
     }
   }
 }
@@ -338,13 +315,31 @@ export async function createApp(
   }
 
   const copyFiles = createCopyFiles(environment, targetDir)
-  const templateFile = createTemplateFile(
+  const templateFileFromContent = createTemplateFile(
     environment,
     options.projectName,
     options,
     targetDir,
   )
 
+  async function templateFile(
+    templateBase: string,
+    file: string,
+    targetFileName?: string,
+    extraTemplateValues?: Record<string, any>,
+  ) {
+    const content = await environment.readFile(
+      resolve(templateBase, file),
+      'utf-8',
+    )
+    return templateFileFromContent(
+      file,
+      content.toString(),
+      targetFileName,
+      extraTemplateValues,
+    )
+  }
+
   const isAddOnEnabled = (id: string) =>
     options.chosenAddOns.find((a) => a.id === id)
 
@@ -448,15 +443,16 @@ export async function createApp(
       (addOn) => addOn.phase === phase,
     )) {
       s?.start(`Setting up ${addOn.name}...`)
-      const addOnDir = resolve(addOn.directory, 'assets')
-      if (environment.exists(addOnDir)) {
-        await copyFilesRecursively(
-          environment,
-          addOnDir,
-          targetDir,
-          async (file: string, targetFileName?: string) =>
-            templateFile(addOnDir, file, targetFileName),
-        )
+      if (addOn.files) {
+        for (const file of Object.keys(addOn.files)) {
+          copyAddOnFile(
+            environment,
+            addOn.files[file],
+            file,
+            (content, targetFileName) =>
+              templateFileFromContent(targetFileName, content),
+          )
+        }
       }
 
       if (addOn.command) {
diff --git a/src/custom-add-on.ts b/src/custom-add-on.ts
@@ -90,7 +90,15 @@ This is probably because this was created with an older version of create-tsrout
           description: 'A custom add-on',
           author: 'John Doe',
           license: 'MIT',
+          link: 'https://github.com/john-doe/custom-add-on',
           commands: [],
+          shadcnComponents: [],
+          templates: [persistedOptions.mode],
+          routes: [],
+          warning: '',
+          variables: {},
+          type: 'example',
+          phase: 'add-on',
         },
         null,
         2,
@@ -111,11 +119,17 @@ This is probably because this was created with an older version of create-tsrout
     (await readFile('package.json')).toString(),
   )
 
+  info.packageAdditions = {
+    scripts: {},
+    dependencies: {},
+    devDependencies: {},
+  }
+
   if (
     JSON.stringify(originalPackageJson.scripts) !==
     JSON.stringify(currentPackageJson.scripts)
   ) {
-    info.commands.push('start')
+    info.packageAdditions.scripts = currentPackageJson.scripts
   }
 
   const dependencies: Record<string, string> = {}
@@ -127,7 +141,7 @@ This is probably because this was created with an older version of create-tsrout
       dependencies[dependency] = currentPackageJson.dependencies[dependency]
     }
   }
-  info.dependencies = dependencies
+  info.packageAdditions.dependencies = dependencies
 
   const devDependencies: Record<string, string> = {}
   for (const dependency of Object.keys(currentPackageJson.devDependencies)) {
@@ -139,7 +153,7 @@ This is probably because this was created with an older version of create-tsrout
         currentPackageJson.devDependencies[dependency]
     }
   }
-  info.devDependencies = devDependencies
+  info.packageAdditions.devDependencies = devDependencies
 
   const changedFiles: Record<string, string> = {}
   await compareFiles('.', originalOutput.files, changedFiles)
diff --git a/src/environment.ts b/src/environment.ts
@@ -10,21 +10,7 @@ import { dirname } from 'node:path'
 import { execa } from 'execa'
 import { memfs } from 'memfs'
 
-export type Environment = {
-  startRun: () => void
-  finishRun: () => void
-  getErrors: () => Array<string>
-
-  appendFile: (path: string, contents: string) => Promise<void>
-  copyFile: (from: string, to: string) => Promise<void>
-  writeFile: (path: string, contents: string) => Promise<void>
-  execute: (command: string, args: Array<string>, cwd: string) => Promise<void>
-
-  readFile: (path: string, encoding?: BufferEncoding) => Promise<string>
-  exists: (path: string) => boolean
-  readdir: (path: string) => Array<string>
-  isDirectory: (path: string) => boolean
-}
+import type { Environment } from './types.js'
 
 export function createDefaultEnvironment(): Environment {
   let errors: Array<string> = []
diff --git a/src/options.ts b/src/options.ts
diff --git a/src/types.ts b/src/types.ts
