@tanstack/cta-engine 0.14.3 → 0.14.4

package/src/environment.ts

@@ -3,13 +3,21 @@ import {
   copyFile,
   mkdir,
   readFile,
+  readdir,
   unlink,
   writeFile,
 } from 'node:fs/promises'
-import { existsSync, readdirSync, statSync } 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,37 +42,63 @@ 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: (path: string, encoding?: BufferEncoding) =>
-      readFile(path, { encoding: encoding || 'utf8' }),
+    readFile: async (path: string) => {
+      return (await readFile(path)).toString()
+    },
     exists: (path: string) => existsSync(path),
-    readdir: (path) => readdirSync(path),
-    isDirectory: (path) => {
-      const stat = statSync(path)
-      return stat.isDirectory()
+    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: () => {},
+    info: () => {},
+    error: () => {},
+    warn: () => {},
+    confirm: () => Promise.resolve(true),
+    spinner: () => ({
+      start: () => {},
+      stop: () => {},
+    }),
   }
 }
 
-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>
@@ -72,70 +106,71 @@ export function createMemoryEnvironment() {
   } = {
     files: {},
     commands: [],
+    deletedFiles: [],
   }
 
   const { fs, vol } = memfs({})
 
-  const cwd = process.cwd()
-  const isInCwd = (path: string) => path.startsWith(cwd)
-  const isTemplatePath = (path: string) => !isInCwd(path)
-
   environment.appendFile = async (path: string, contents: string) => {
     fs.mkdirSync(dirname(path), { recursive: true })
     await fs.appendFileSync(path, contents)
   }
   environment.copyFile = async (from: string, to: string) => {
-    if (isTemplatePath(from)) {
-      const contents = (await readFile(from)).toString()
-      fs.mkdirSync(dirname(to), { recursive: true })
-      fs.writeFileSync(to, contents)
-    } else {
-      fs.mkdirSync(dirname(to), { recursive: true })
-      fs.copyFileSync(from, to)
-    }
+    fs.mkdirSync(dirname(to), { recursive: true })
+    fs.copyFileSync(from, to)
+    return Promise.resolve()
   }
   environment.execute = async (command: string, args: Array<string>) => {
     output.commands.push({
       command,
       args,
     })
-    return Promise.resolve()
+    return Promise.resolve({ stdout: '' })
   }
-  environment.readFile = async (path: string, encoding?: BufferEncoding) => {
-    if (isTemplatePath(path)) {
-      return (await readFile(path, encoding)).toString()
-    }
-    return fs.readFileSync(path, 'utf8').toString()
+  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.readdir = (path: string) => {
-    if (isTemplatePath(path)) {
-      return readdirSync(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]
+      }
     }
-    return fs.readdirSync(path).map((file) => file.toString())
-  }
-  environment.isDirectory = (path) => {
-    if (isTemplatePath(path)) {
-      const stat = statSync(path)
-      return stat.isDirectory()
+    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.finishRun = () => {
-    output.files = vol.toJSON() as Record<string, string>
+  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

@@ -0,0 +1,235 @@
+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 (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')
+    return binaryContent as unknown as string
+  }
+  return null
+}
+
+export function relativePath(from: string, to: string) {
+  const cleanedFrom = from.startsWith('./') ? from.slice(2) : from
+  const cleanedTo = to.startsWith('./') ? to.slice(2) : to
+
+  const fromSegments = cleanedFrom.split('/')
+  const toSegments = cleanedTo.split('/')
+
+  fromSegments.pop()
+  toSegments.pop()
+
+  let commonIndex = 0
+  while (
+    commonIndex < fromSegments.length &&
+    commonIndex < toSegments.length &&
+    fromSegments[commonIndex] === toSegments[commonIndex]
+  ) {
+    commonIndex++
+  }
+
+  const upLevels = fromSegments.length - commonIndex
+  const downLevels = toSegments.slice(commonIndex)
+
+  if (upLevels === 0 && downLevels.length === 0) {
+    return `./${basename(to)}`
+  } else if (upLevels === 0 && downLevels.length > 0) {
+    return `./${downLevels.join('/')}/${basename(to)}`
+  } else {
+    const relativePath = [...Array(upLevels).fill('..'), ...downLevels].join(
+      '/',
+    )
+    return `${relativePath}/${basename(to)}`
+  }
+}
+
+export function isDirectory(path: string): boolean {
+  return statSync(path).isDirectory()
+}
+
+export 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] = readFileHelper(filePath)
+    }
+  }
+}
+
+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

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import {
+  findFilesRecursively,
+  isDirectory,
+  readFileHelper,
+} from './file-helpers.js'
+
+import type { AddOn, Framework, FrameworkDefinition } from './types.js'
+
+const frameworks: Array<Framework> = []
+
+function getAddOns(framework: FrameworkDefinition) {
+  const addOns: Array<AddOn> = []
+
+  for (const addOnsBase of framework.addOnsDirectories) {
+    for (const dir of readdirSync(addOnsBase).filter((file) =>
+      isDirectory(resolve(addOnsBase, file)),
+    )) {
+      const filePath = resolve(addOnsBase, dir, 'info.json')
+      const fileContent = readFileSync(filePath, 'utf-8')
+      const info = JSON.parse(fileContent)
+
+      let packageAdditions: Record<string, string> = {}
+      if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
+        packageAdditions = JSON.parse(
+          readFileSync(resolve(addOnsBase, dir, 'package.json'), 'utf-8'),
+        )
+      }
+
+      let readme: string | undefined
+      if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
+        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)) {
+        findFilesRecursively(assetsDir, absoluteFiles)
+      }
+      const files: Record<string, string> = {}
+      for (const file of Object.keys(absoluteFiles)) {
+        files[file.replace(assetsDir, '.')] = readFileHelper(file)
+      }
+
+      const getFiles = () => {
+        return Promise.resolve(Object.keys(files))
+      }
+      const getFileContents = (path: string) => {
+        return Promise.resolve(files[path])
+      }
+
+      addOns.push({
+        ...info,
+        id: dir,
+        packageAdditions,
+        readme,
+        files,
+        smallLogo,
+        getFiles,
+        getFileContents,
+        getDeletedFiles: () => Promise.resolve(info.deletedFiles ?? []),
+      })
+    }
+  }
+
+  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')
+
+  const basePackageJSON = JSON.parse(
+    readFileSync(resolve(baseAssetsDirectory, 'package.json'), 'utf8'),
+  )
+  const optionalPackages = JSON.parse(
+    readFileSync(resolve(framework.baseDirectory, 'packages.json'), 'utf8'),
+  )
+
+  const addOns = getAddOns(framework)
+
+  const frameworkWithBundler: Framework = {
+    ...framework,
+    getFiles: () => {
+      const files: Record<string, string> = {}
+      findFilesRecursively(baseAssetsDirectory, files)
+      return Promise.resolve(
+        Object.keys(files).map((path) =>
+          path.replace(baseAssetsDirectory, '.'),
+        ),
+      )
+    },
+    getFileContents: (path: string) => {
+      return Promise.resolve(readFileHelper(resolve(baseAssetsDirectory, path)))
+    },
+    getDeletedFiles: () => {
+      return Promise.resolve([])
+    },
+    basePackageJSON,
+    optionalPackages,
+    getAddOns: () => addOns,
+  }
+
+  frameworks.push(frameworkWithBundler)
+}
+
+export function getFrameworkById(id: string) {
+  return frameworks.find((framework) => framework.id === id)
+}
+
+export function getFrameworkByName(name: string) {
+  return frameworks.find((framework) => framework.name === name)
+}
+
+export function getFrameworks() {
+  return frameworks
+}

package/src/index.ts

@@ -1 +1,85 @@
-export { cli } from './cli.js'
+export { createApp } from './create-app.js'
+export { addToApp } from './add-to-app.js'
+
+export { finalizeAddOns, getAllAddOns } from './add-ons.js'
+
+export { loadRemoteAddOn } from './custom-add-ons/add-on.js'
+export { loadStarter } from './custom-add-ons/starter.js'
+
+export {
+  createMemoryEnvironment,
+  createDefaultEnvironment,
+} from './environment.js'
+
+export { CODE_ROUTER, CONFIG_FILE, FILE_ROUTER } from './constants.js'
+
+export {
+  DEFAULT_PACKAGE_MANAGER,
+  SUPPORTED_PACKAGE_MANAGERS,
+  getPackageManager,
+} from './package-manager.js'
+
+export {
+  registerFramework,
+  getFrameworkById,
+  getFrameworkByName,
+  getFrameworks,
+} from './frameworks.js'
+
+export {
+  writeConfigFileToEnvironment,
+  readConfigFileFromEnvironment,
+  readConfigFile,
+} from './config-file.js'
+
+export {
+  cleanUpFiles,
+  cleanUpFileArray,
+  readFileHelper,
+  getBinaryFile,
+  recursivelyGatherFiles,
+  relativePath,
+} from './file-helpers.js'
+
+export { formatCommand } from './utils.js'
+
+export { initStarter, compileStarter } from './custom-add-ons/starter.js'
+export { initAddOn, compileAddOn } from './custom-add-ons/add-on.js'
+export {
+  createAppOptionsFromPersisted,
+  createSerializedOptionsFromPersisted,
+} from './custom-add-ons/shared.js'
+
+export { createSerializedOptions } from './options.js'
+
+export {
+  getRawRegistry,
+  getRegistry,
+  getRegistryAddOns,
+  getRegistryStarters,
+} from './registry.js'
+
+export {
+  StarterCompiledSchema,
+  StatusEvent,
+  StatusStepType,
+  StopEvent,
+  AddOnCompiledSchema,
+  AddOnInfoSchema,
+  IntegrationSchema,
+} from './types.js'
+
+export type {
+  AddOn,
+  Environment,
+  FileBundleHandler,
+  Framework,
+  FrameworkDefinition,
+  Mode,
+  Options,
+  SerializedOptions,
+  Starter,
+  StarterCompiled,
+} from './types.js'
+export type { PersistedOptions } from './config-file.js'
+export type { PackageManager } from './package-manager.js'

package/src/integrations/git.ts

@@ -0,0 +1,7 @@
+import { resolve } from 'node:path'
+
+import type { Environment } from '../types.js'
+
+export async function setupGit(environment: Environment, targetDir: string) {
+  await environment.execute('git', ['init'], resolve(targetDir))
+}