@tanstack/cta-engine 0.10.0-alpha.19 → 0.10.0-alpha.21

package/src/custom-add-ons/shared.ts

@@ -0,0 +1,161 @@
+import { readdir } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { createApp } from '../create-app.js'
+import { createMemoryEnvironment } from '../environment.js'
+import { finalizeAddOns } from '../add-ons.js'
+import { getFrameworkById } from '../frameworks.js'
+import { readConfigFileFromEnvironment } from '../config-file.js'
+import { readFileHelper } from '../file-helpers.js'
+import { loadStarter } from '../custom-add-ons/starter.js'
+
+import type { Environment, Mode, Options, SerializedOptions } from '../types.js'
+import type { PersistedOptions } from '../config-file.js'
+
+export function createPackageAdditions(
+  originalPackageJson: Record<string, any>,
+  currentPackageJson: Record<string, any>,
+) {
+  const packageAdditions: Record<string, any> = {}
+
+  const scripts: Record<string, any> = {}
+  for (const script of Object.keys(currentPackageJson.scripts || {})) {
+    if (
+      originalPackageJson.scripts[script] !== currentPackageJson.scripts[script]
+    ) {
+      scripts[script] = currentPackageJson.scripts[script]
+    }
+  }
+  packageAdditions.scripts = Object.keys(scripts).length ? scripts : undefined
+
+  const dependencies: Record<string, string> = {}
+  for (const dependency of Object.keys(currentPackageJson.dependencies || {})) {
+    if (
+      originalPackageJson.dependencies[dependency] !==
+      currentPackageJson.dependencies[dependency]
+    ) {
+      dependencies[dependency] = currentPackageJson.dependencies[dependency]
+    }
+  }
+  packageAdditions.dependencies = Object.keys(dependencies).length
+    ? dependencies
+    : undefined
+
+  const devDependencies: Record<string, string> = {}
+  for (const dependency of Object.keys(
+    currentPackageJson.devDependencies || {},
+  )) {
+    if (
+      originalPackageJson.devDependencies[dependency] !==
+      currentPackageJson.devDependencies[dependency]
+    ) {
+      devDependencies[dependency] =
+        currentPackageJson.devDependencies[dependency]
+    }
+  }
+  packageAdditions.devDependencies = Object.keys(devDependencies).length
+    ? devDependencies
+    : undefined
+
+  return packageAdditions
+}
+
+export async function createAppOptionsFromPersisted(
+  json: PersistedOptions,
+): Promise<Options> {
+  /* eslint-disable unused-imports/no-unused-vars */
+  const { version, ...rest } = json
+  /* eslint-enable unused-imports/no-unused-vars */
+  const framework = getFrameworkById(rest.framework)
+  return {
+    ...rest,
+    mode: json.mode as Mode,
+    projectName: json.projectName!,
+    typescript: json.typescript!,
+    tailwind: json.tailwind!,
+    git: json.git!,
+    packageManager: json.packageManager!,
+    targetDir: '',
+    framework: framework!,
+    starter: json.starter ? await loadStarter(json.starter) : undefined,
+    chosenAddOns: await finalizeAddOns(framework!, json.mode as Mode, [
+      ...json.existingAddOns,
+    ]),
+  }
+}
+
+export function createSerializedOptionsFromPersisted(
+  json: PersistedOptions,
+): SerializedOptions {
+  /* eslint-disable unused-imports/no-unused-vars */
+  const { version, ...rest } = json
+  /* eslint-enable unused-imports/no-unused-vars */
+  return {
+    ...rest,
+    mode: json.mode as Mode,
+    projectName: json.projectName!,
+    typescript: json.typescript!,
+    tailwind: json.tailwind!,
+    git: json.git!,
+    packageManager: json.packageManager!,
+    targetDir: '',
+    framework: json.framework,
+    starter: json.starter,
+    chosenAddOns: json.existingAddOns,
+  }
+}
+
+export async function runCreateApp(options: Required<Options>) {
+  const { environment, output } = createMemoryEnvironment()
+
+  const targetDir = resolve(process.cwd())
+
+  await createApp(environment, {
+    ...options,
+    targetDir,
+  })
+
+  output.files = Object.fromEntries(
+    Object.entries(output.files).map(([key, value]) => {
+      return [key.replace(targetDir, '.'), value]
+    }),
+  )
+
+  return output
+}
+
+export async function compareFilesRecursively(
+  path: string,
+  ignore: (filePath: string) => boolean,
+  original: Record<string, string>,
+  changedFiles: Record<string, string>,
+) {
+  const files = await readdir(path, { withFileTypes: true })
+  for (const file of files) {
+    const filePath = `${path}/${file.name}`
+    if (!ignore(file.name)) {
+      if (file.isDirectory()) {
+        await compareFilesRecursively(filePath, ignore, original, changedFiles)
+      } else {
+        const contents = await readFileHelper(filePath)
+        if (!original[filePath] || original[filePath] !== contents) {
+          changedFiles[filePath] = contents
+        }
+      }
+    }
+  }
+}
+
+export async function readCurrentProjectOptions(environment: Environment) {
+  const persistedOptions = await readConfigFileFromEnvironment(
+    environment,
+    process.cwd(),
+  )
+  if (!persistedOptions) {
+    environment.error(
+      'There is no .cta.json file in your project.',
+      `This is probably because this was created with an older version of create-tsrouter-app.`,
+    )
+    process.exit(1)
+  }
+  return persistedOptions
+}

package/src/custom-add-ons/starter.ts

@@ -0,0 +1,126 @@
+import { readFile } from 'node:fs/promises'
+import { existsSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { StarterCompiledSchema } from '../types.js'
+import { createIgnore } from '../file-helpers.js'
+import {
+  compareFilesRecursively,
+  createAppOptionsFromPersisted,
+  createPackageAdditions,
+  readCurrentProjectOptions,
+  runCreateApp,
+} from './shared.js'
+
+import type { PersistedOptions } from '../config-file'
+import type {
+  Environment,
+  Options,
+  Starter,
+  StarterCompiled,
+  StarterInfo,
+} from '../types'
+
+const INFO_FILE = 'starter-info.json'
+const COMPILED_FILE = 'starter.json'
+
+export async function readOrGenerateStarterInfo(
+  options: PersistedOptions,
+): Promise<StarterInfo> {
+  return existsSync(INFO_FILE)
+    ? JSON.parse((await readFile(INFO_FILE)).toString())
+    : {
+        id: `${options.projectName}-starter`,
+        name: `${options.projectName}-starter`,
+        version: '0.0.1',
+        description: 'Project starter',
+        author: 'Jane Smith <jane.smith@example.com>',
+        license: 'MIT',
+        link: `https://github.com/jane-smith/${options.projectName}-starter`,
+        shadcnComponents: [],
+        framework: options.framework,
+        mode: options.mode!,
+        routes: [],
+        warning: '',
+        type: 'starter',
+        packageAdditions: {
+          scripts: {},
+          dependencies: {},
+          devDependencies: {},
+        },
+        dependsOn: options.existingAddOns,
+        typescript: options.typescript!,
+        tailwind: options.tailwind!,
+      }
+}
+
+async function loadCurrentStarterInfo(environment: Environment) {
+  const persistedOptions = await readCurrentProjectOptions(environment)
+  const info = await readOrGenerateStarterInfo(persistedOptions)
+
+  const output = await runCreateApp(
+    (await createAppOptionsFromPersisted(
+      persistedOptions,
+    )) as Required<Options>,
+  )
+
+  return { info, output }
+}
+
+export async function updateStarterInfo(environment: Environment) {
+  const { info, output } = await loadCurrentStarterInfo(environment)
+
+  info.packageAdditions = createPackageAdditions(
+    JSON.parse(output.files['./package.json']),
+    JSON.parse((await readFile('package.json')).toString()),
+  )
+
+  writeFileSync(INFO_FILE, JSON.stringify(info, null, 2))
+}
+
+export async function compileStarter(environment: Environment) {
+  const { info, output } = await loadCurrentStarterInfo(environment)
+
+  const ignore = createIgnore(process.cwd())
+  const changedFiles: Record<string, string> = {}
+  await compareFilesRecursively('.', ignore, output.files, changedFiles)
+
+  const deletedFiles: Array<string> = []
+  for (const file of Object.keys(output.files)) {
+    if (!existsSync(resolve(process.cwd(), file))) {
+      deletedFiles.push(file)
+    }
+  }
+
+  const compiledInfo: StarterCompiled = {
+    ...info,
+    files: changedFiles,
+    deletedFiles,
+  }
+
+  writeFileSync(COMPILED_FILE, JSON.stringify(compiledInfo, null, 2))
+}
+
+export async function initStarter(environment: Environment) {
+  await updateStarterInfo(environment)
+  await compileStarter(environment)
+}
+
+export async function loadStarter(url: string): Promise<Starter> {
+  const response = await fetch(url)
+  const jsonContent = await response.json()
+
+  const checked = StarterCompiledSchema.safeParse(jsonContent)
+  if (!checked.success) {
+    throw new Error(`Invalid starter: ${url}`)
+  }
+
+  const starter = checked.data
+  starter.id = url
+  return {
+    ...starter,
+    getFiles: () => Promise.resolve(Object.keys(starter.files)),
+    getFileContents: (path: string) => Promise.resolve(starter.files[path]),
+    getDeletedFiles: () => Promise.resolve(starter.deletedFiles),
+  }
+}

package/src/environment.ts

@@ -3,13 +3,21 @@ import {
   copyFile,
   mkdir,
   readFile,
+  readdir,
   unlink,
   writeFile,
 } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
+import { existsSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { execa } from 'execa'
 import { memfs } from 'memfs'
+import { rimraf } from 'rimraf'
+
+import {
+  cleanUpFileArray,
+  cleanUpFiles,
+  getBinaryFile,
+} from './file-helpers.js'
 
 import type { Environment } from './types.js'
 
@@ -34,22 +42,43 @@ export function createDefaultEnvironment(): Environment {
       await mkdir(dirname(path), { recursive: true })
       return writeFile(path, contents)
     },
+    writeFileBase64: async (path: string, base64Contents: string) => {
+      await mkdir(dirname(path), { recursive: true })
+      return writeFile(path, getBinaryFile(base64Contents) as string)
+    },
     execute: async (command: string, args: Array<string>, cwd: string) => {
       try {
-        await execa(command, args, {
+        const result = await execa(command, args, {
           cwd,
         })
+        return { stdout: result.stdout }
       } catch {
         errors.push(
           `Command "${command} ${args.join(' ')}" did not run successfully. Please run this manually in your project.`,
         )
+        return { stdout: '' }
       }
     },
     deleteFile: async (path: string) => {
-      await unlink(path)
+      if (existsSync(path)) {
+        await unlink(path)
+      }
     },
 
+    readFile: async (path: string) => {
+      return (await readFile(path)).toString()
+    },
     exists: (path: string) => existsSync(path),
+    isDirectory: (path: string) => statSync(path).isDirectory(),
+    readdir: async (path: string) => readdir(path),
+    rimraf: async (path: string) => {
+      await rimraf(path)
+    },
+
+    appName: 'TanStack',
+
+    startStep: () => {},
+    finishStep: () => {},
 
     intro: () => {},
     outro: () => {},
@@ -64,11 +93,12 @@ export function createDefaultEnvironment(): Environment {
   }
 }
 
-export function createMemoryEnvironment() {
+export function createMemoryEnvironment(returnPathsRelativeTo: string = '') {
   const environment = createDefaultEnvironment()
 
   const output: {
     files: Record<string, string>
+    deletedFiles: Array<string>
     commands: Array<{
       command: string
       args: Array<string>
@@ -76,6 +106,7 @@ export function createMemoryEnvironment() {
   } = {
     files: {},
     commands: [],
+    deletedFiles: [],
   }
 
   const { fs, vol } = memfs({})
@@ -103,24 +134,52 @@ export function createMemoryEnvironment() {
       command,
       args,
     })
-    return Promise.resolve()
+    return Promise.resolve({ stdout: '' })
+  }
+  environment.readFile = async (path: string) => {
+    return Promise.resolve(fs.readFileSync(path, 'utf-8').toString())
   }
   environment.writeFile = async (path: string, contents: string) => {
     fs.mkdirSync(dirname(path), { recursive: true })
     await fs.writeFileSync(path, contents)
   }
-  environment.deleteFile = async (path: string) => {
-    await fs.unlinkSync(path)
+  environment.writeFileBase64 = async (path: string, contents: string) => {
+    // For the in-memory file system, we are not converting the base64 to binary
+    // because it's not needed.
+    fs.mkdirSync(dirname(path), { recursive: true })
+    await fs.writeFileSync(path, contents)
   }
-  environment.exists = (path: string) => {
-    if (isTemplatePath(path)) {
-      return existsSync(path)
+  environment.deleteFile = async (path: string) => {
+    output.deletedFiles.push(path)
+    if (fs.existsSync(path)) {
+      await fs.unlinkSync(path)
     }
-    return fs.existsSync(path)
   }
   environment.finishRun = () => {
     output.files = vol.toJSON() as Record<string, string>
+    for (const file of Object.keys(output.files)) {
+      if (fs.statSync(file).isDirectory()) {
+        delete output.files[file]
+      }
+    }
+    if (returnPathsRelativeTo.length) {
+      output.files = cleanUpFiles(output.files, returnPathsRelativeTo)
+      output.deletedFiles = cleanUpFileArray(
+        output.deletedFiles,
+        returnPathsRelativeTo,
+      )
+    }
+  }
+  environment.exists = (path: string) => {
+    return fs.existsSync(path)
+  }
+  environment.isDirectory = (path: string) => {
+    return fs.statSync(path).isDirectory()
+  }
+  environment.readdir = async (path: string) => {
+    return Promise.resolve(fs.readdirSync(path).map((d) => d.toString()))
   }
+  environment.rimraf = async () => {}
 
   return {
     environment,

package/src/file-helpers.ts

@@ -1,16 +1,33 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { readdir } from 'node:fs/promises'
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { basename, extname, resolve } from 'node:path'
+import parseGitignore from 'parse-gitignore'
+import ignore from 'ignore'
+
+import type { Environment } from './types'
 
 const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico']
 
 export function readFileHelper(path: string): string {
-  if (BINARY_EXTENSIONS.includes(extname(path))) {
+  if (isBinaryFile(path)) {
     return `base64::${readFileSync(path).toString('base64')}`
   } else {
     return readFileSync(path, 'utf-8').toString()
   }
 }
 
+export function isBinaryFile(path: string): boolean {
+  return BINARY_EXTENSIONS.includes(extname(path))
+}
+
+export function convertBinaryContentsToBase64(contents: any): string {
+  return `base64::${Buffer.from(contents).toString('base64')}`
+}
+
+export function isBase64(content: string): boolean {
+  return content.startsWith('base64::')
+}
+
 export function getBinaryFile(content: string): string | null {
   if (content.startsWith('base64::')) {
     const binaryContent = Buffer.from(content.replace('base64::', ''), 'base64')
@@ -71,3 +88,148 @@ export function findFilesRecursively(
     }
   }
 }
+
+async function recursivelyGatherFilesHelper(
+  basePath: string,
+  path: string,
+  files: Record<string, string>,
+  ignore: (filePath: string) => boolean,
+) {
+  const dirFiles = await readdir(path, { withFileTypes: true })
+  for (const file of dirFiles) {
+    if (ignore(file.name)) {
+      continue
+    }
+    if (file.isDirectory()) {
+      await recursivelyGatherFilesHelper(
+        basePath,
+        resolve(path, file.name),
+        files,
+        ignore,
+      )
+    } else {
+      const filePath = resolve(path, file.name)
+      files[filePath.replace(basePath, '.')] = await readFileHelper(filePath)
+    }
+  }
+}
+
+export async function recursivelyGatherFiles(
+  path: string,
+  includeProjectFiles = true,
+) {
+  const ignore = createIgnore(path, includeProjectFiles)
+  const files: Record<string, string> = {}
+  await recursivelyGatherFilesHelper(path, path, files, ignore)
+  return files
+}
+
+async function recursivelyGatherFilesFromEnvironmentHelper(
+  environment: Environment,
+  basePath: string,
+  path: string,
+  files: Record<string, string>,
+  ignore: (filePath: string) => boolean,
+) {
+  const dirFiles = await environment.readdir(path)
+  for (const file of dirFiles) {
+    if (ignore(file)) {
+      continue
+    }
+    if (environment.isDirectory(resolve(path, file))) {
+      await recursivelyGatherFilesFromEnvironmentHelper(
+        environment,
+        basePath,
+        resolve(path, file),
+        files,
+        ignore,
+      )
+    } else {
+      const filePath = resolve(path, file)
+      files[filePath.replace(basePath, '.')] =
+        await environment.readFile(filePath)
+    }
+  }
+}
+
+export async function recursivelyGatherFilesFromEnvironment(
+  environment: Environment,
+  path: string,
+  includeProjectFiles = true,
+) {
+  const ignore = createIgnore(path, includeProjectFiles)
+  const files: Record<string, string> = {}
+  await recursivelyGatherFilesFromEnvironmentHelper(
+    environment,
+    path,
+    path,
+    files,
+    ignore,
+  )
+  return files
+}
+
+export const IGNORE_FILES = [
+  '.starter',
+  '.add-on',
+  '.cta.json',
+  '.git',
+  'add-on-info.json',
+  'add-on.json',
+  'build',
+  'bun.lock',
+  'bun.lockb',
+  'deno.lock',
+  'dist',
+  'node_modules',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'starter.json',
+  'starter-info.json',
+  'yarn.lock',
+]
+
+const PROJECT_FILES = ['package.json']
+
+export function createIgnore(path: string, includeProjectFiles = true) {
+  const ignoreList = existsSync(resolve(path, '.gitignore'))
+    ? (
+        parseGitignore(
+          readFileSync(resolve(path, '.gitignore')),
+        ) as unknown as { patterns: Array<string> }
+      ).patterns
+    : []
+  const ig = ignore().add(ignoreList)
+  return (filePath: string) => {
+    const fileName = basename(filePath)
+    if (
+      IGNORE_FILES.includes(fileName) ||
+      (includeProjectFiles && PROJECT_FILES.includes(fileName))
+    ) {
+      return true
+    }
+    const nameWithoutDotSlash = fileName.replace(/^\.\//, '')
+    return ig.ignores(nameWithoutDotSlash)
+  }
+}
+
+export function cleanUpFiles(
+  files: Record<string, string>,
+  targetDir?: string,
+) {
+  return Object.keys(files).reduce<Record<string, string>>((acc, file) => {
+    if (basename(file) !== '.cta.json') {
+      acc[targetDir ? file.replace(targetDir, '.') : file] = files[file]
+    }
+    return acc
+  }, {})
+}
+
+export function cleanUpFileArray(files: Array<string>, targetDir?: string) {
+  return files.reduce<Array<string>>((acc, file) => {
+    if (basename(file) !== '.cta.json') {
+      acc.push(targetDir ? file.replace(targetDir, '.') : file)
+    }
+    return acc
+  }, [])
+}

package/src/frameworks.ts

@@ -34,6 +34,14 @@ function getAddOns(framework: FrameworkDefinition) {
         readme = readFileSync(resolve(addOnsBase, dir, 'README.md'), 'utf-8')
       }
 
+      let smallLogo: string | undefined
+      if (existsSync(resolve(addOnsBase, dir, 'small-logo.svg'))) {
+        smallLogo = readFileSync(
+          resolve(addOnsBase, dir, 'small-logo.svg'),
+          'utf-8',
+        )
+      }
+
       const absoluteFiles: Record<string, string> = {}
       const assetsDir = resolve(addOnsBase, dir, 'assets')
       if (existsSync(assetsDir)) {
@@ -57,9 +65,10 @@ function getAddOns(framework: FrameworkDefinition) {
         packageAdditions,
         readme,
         files,
-        deletedFiles: [],
+        smallLogo,
         getFiles,
         getFileContents,
+        getDeletedFiles: () => Promise.resolve(info.deletedFiles ?? []),
       })
     }
   }
@@ -67,6 +76,14 @@ function getAddOns(framework: FrameworkDefinition) {
   return addOns
 }
 
+export function __testRegisterFramework(framework: Framework) {
+  frameworks.push(framework)
+}
+
+export function __testClearFrameworks() {
+  frameworks.length = 0
+}
+
 export function registerFramework(framework: FrameworkDefinition) {
   const baseAssetsDirectory = resolve(framework.baseDirectory, 'base')
 
@@ -93,6 +110,9 @@ export function registerFramework(framework: FrameworkDefinition) {
     getFileContents: (path: string) => {
       return Promise.resolve(readFileHelper(resolve(baseAssetsDirectory, path)))
     },
+    getDeletedFiles: () => {
+      return Promise.resolve([])
+    },
     basePackageJSON,
     optionalPackages,
     getAddOns: () => addOns,