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

package/src/index.ts

@@ -1,42 +1,77 @@
 export { createApp } from './create-app.js'
 export { addToApp } from './add-to-app.js'
 
-export { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.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,
-  getPackageManagerInstallCommand,
-  getPackageManagerExecuteCommand,
-  getPackageManagerScriptCommand,
-  packageManagerInstall,
-  packageManagerExecute,
 } from './package-manager.js'
+
 export {
   registerFramework,
   getFrameworkById,
   getFrameworkByName,
   getFrameworks,
 } from './frameworks.js'
-export { formatCommand, jsSafeName, sortObject } from './utils.js'
-export { writeConfigFile, readConfigFile } from './config-file.js'
-export { readFileHelper, getBinaryFile, relativePath } from './file-helpers.js'
+
+export {
+  writeConfigFileToEnvironment,
+  readConfigFileFromEnvironment,
+} 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 {
+  StarterCompiledSchema,
+  StatusEvent,
+  StatusStepType,
+  StopEvent,
+  AddOnCompiledSchema,
+  AddOnInfoSchema,
+  IntegrationSchema,
+} from './types.js'
 
 export type {
   AddOn,
   Environment,
   FileBundleHandler,
+  Framework,
   FrameworkDefinition,
   Mode,
   Options,
+  SerializedOptions,
   Starter,
-  TemplateOptions,
-  Variable,
+  StarterCompiled,
 } from './types.js'
 export type { PersistedOptions } from './config-file.js'
 export type { PackageManager } from './package-manager.js'

package/src/integrations/shadcn.ts

@@ -6,9 +6,8 @@ export async function installShadcnComponents(
   environment: Environment,
   targetDir: string,
   options: Options,
-  silent: boolean,
 ) {
-  const s = silent ? null : environment.spinner()
+  const s = environment.spinner()
 
   if (options.chosenAddOns.find((a) => a.id === 'shadcn')) {
     const shadcnComponents = new Set<string>()
@@ -28,9 +27,15 @@ export async function installShadcnComponents(
     }
 
     if (shadcnComponents.size > 0) {
-      s?.start(
+      s.start(
         `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
       )
+      environment.startStep({
+        id: 'install-shadcn-components',
+        type: 'command',
+        message: `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
+      })
+
       await packageManagerExecute(
         environment,
         resolve(targetDir),
@@ -38,7 +43,12 @@ export async function installShadcnComponents(
         'shadcn@latest',
         ['add', '--silent', '--yes', ...Array.from(shadcnComponents)],
       )
-      s?.stop(`Installed additional shadcn components`)
+
+      environment.finishStep(
+        'install-shadcn-components',
+        'Shadcn components installed',
+      )
+      s.stop(`Installed additional shadcn components`)
     }
   }
 }

package/src/options.ts

@@ -0,0 +1,11 @@
+import type { Options, SerializedOptions } from './types'
+
+export const createSerializedOptions = (options: Options) => {
+  const serializedOptions: SerializedOptions = {
+    ...options,
+    chosenAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+    framework: options.framework.id,
+    starter: options.starter?.id,
+  }
+  return serializedOptions
+}

package/src/package-json.ts

@@ -3,23 +3,23 @@ import { sortObject } from './utils.js'
 
 import type { Options } from './types.js'
 
-function mergePackageJSON(
+export function mergePackageJSON(
   packageJSON: Record<string, any>,
-  overlayPackageJSON: Record<string, any>,
+  overlayPackageJSON?: Record<string, any>,
 ) {
   return {
     ...packageJSON,
     dependencies: {
       ...packageJSON.dependencies,
-      ...overlayPackageJSON.dependencies,
+      ...(overlayPackageJSON?.dependencies || {}),
     },
     devDependencies: {
       ...packageJSON.devDependencies,
-      ...overlayPackageJSON.devDependencies,
+      ...(overlayPackageJSON?.devDependencies || {}),
     },
     scripts: {
       ...packageJSON.scripts,
-      ...overlayPackageJSON.scripts,
+      ...(overlayPackageJSON?.scripts || {}),
     },
   }
 }
@@ -42,7 +42,7 @@ export function createPackageJSON(options: Options) {
       : undefined,
   ]
   for (const addition of additions.filter(Boolean)) {
-    packageJSON = mergePackageJSON(packageJSON, addition!)
+    packageJSON = mergePackageJSON(packageJSON, addition)
   }
 
   for (const addOn of options.chosenAddOns.map(
@@ -51,6 +51,13 @@ export function createPackageJSON(options: Options) {
     packageJSON = mergePackageJSON(packageJSON, addOn)
   }
 
+  if (options.starter) {
+    packageJSON = mergePackageJSON(
+      packageJSON,
+      options.starter.packageAdditions,
+    )
+  }
+
   packageJSON.dependencies = sortObject(
     (packageJSON.dependencies ?? {}) as Record<string, string>,
   )

package/src/special-steps/index.ts

@@ -0,0 +1,36 @@
+import { rimrafNodeModules } from './rimraf-node-modules.js'
+
+import type { Environment, Options } from '../types.js'
+
+const specialStepsLookup: Record<
+  string,
+  (environment: Environment, options: Options) => Promise<void>
+> = {
+  'rimraf-node-modules': rimrafNodeModules,
+}
+
+export async function runSpecialSteps(
+  environment: Environment,
+  options: Options,
+  specialSteps: Array<string>,
+) {
+  if (specialSteps.length) {
+    environment.startStep({
+      id: 'special-steps',
+      type: 'command',
+      message: 'Removing node_modules...',
+    })
+
+    for (const step of specialSteps) {
+      const stepFunction = specialStepsLookup[step]
+      /* eslint-disable @typescript-eslint/no-unnecessary-condition */
+      if (stepFunction) {
+        await stepFunction(environment, options)
+      } else {
+        environment.error(`Special step ${step} not found`)
+      }
+    }
+
+    environment.finishStep('special-steps', 'Special steps complete')
+  }
+}

package/src/special-steps/rimraf-node-modules.ts

@@ -0,0 +1,25 @@
+import { resolve } from 'node:path'
+
+import type { Environment, Options } from '../types.js'
+
+const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml']
+
+export async function rimrafNodeModules(
+  environment: Environment,
+  options: Options,
+) {
+  environment.startStep({
+    id: 'special-steps',
+    type: 'command',
+    message: 'Removing node_modules...',
+  })
+
+  await environment.rimraf(resolve(options.targetDir, 'node_modules'))
+
+  for (const lockFile of lockFiles) {
+    const lockFilePath = resolve(options.targetDir, lockFile)
+    if (environment.exists(lockFilePath)) {
+      await environment.deleteFile(lockFilePath)
+    }
+  }
+}

package/src/template-file.ts

@@ -19,11 +19,7 @@ function convertDotFilesAndPaths(path: string) {
     .join('/')
 }
 
-export function createTemplateFile(
-  environment: Environment,
-  options: Options,
-  targetDir: string,
-) {
+export function createTemplateFile(environment: Environment, options: Options) {
   function getPackageManagerAddScript(
     packageName: string,
     isDev: boolean = false,
@@ -71,16 +67,6 @@ export function createTemplateFile(
     }
   }
 
-  const variables = {
-    ...options.variableValues,
-    ...options.chosenAddOns.reduce<Record<string, any>>((acc, addOn) => {
-      return {
-        ...acc,
-        ...addOn.variables,
-      }
-    }, {}),
-  }
-
   const addOnEnabled = options.chosenAddOns.reduce<Record<string, boolean>>(
     (acc, addOn) => {
       acc[addOn.id] = true
@@ -103,7 +89,6 @@ export function createTemplateFile(
       addOns: options.chosenAddOns,
       integrations,
       routes,
-      variables,
 
       getPackageManagerAddScript,
       getPackageManagerRunScript,
@@ -157,9 +142,9 @@ export function createTemplateFile(
     }
 
     if (append) {
-      await environment.appendFile(resolve(targetDir, target), content)
+      await environment.appendFile(resolve(options.targetDir, target), content)
     } else {
-      await environment.writeFile(resolve(targetDir, target), content)
+      await environment.writeFile(resolve(options.targetDir, target), content)
     }
   }
 }

package/src/types.ts

@@ -1,69 +1,110 @@
+import z from 'zod'
+
 import type { CODE_ROUTER, FILE_ROUTER } from './constants.js'
 import type { PackageManager } from './package-manager.js'
 
-export type TemplateOptions = 'typescript' | 'javascript' | 'file-router'
-
 export type Mode = typeof CODE_ROUTER | typeof FILE_ROUTER
 
+export type StatusStepType =
+  | 'file'
+  | 'command'
+  | 'info'
+  | 'package-manager'
+  | 'other'
+
+export const AddOnBaseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  author: z.string().optional(),
+  version: z.string().optional(),
+  link: z.string().optional(),
+  license: z.string().optional(),
+  warning: z.string().optional(),
+  type: z.enum(['add-on', 'example', 'starter', 'toolchain']),
+  command: z
+    .object({
+      command: z.string(),
+      args: z.array(z.string()).optional(),
+    })
+    .optional(),
+  routes: z
+    .array(
+      z.object({
+        url: z.string().optional(),
+        name: z.string().optional(),
+        path: z.string(),
+        jsName: z.string(),
+      }),
+    )
+    .optional(),
+  packageAdditions: z
+    .object({
+      dependencies: z.record(z.string(), z.string()).optional(),
+      devDependencies: z.record(z.string(), z.string()).optional(),
+      scripts: z.record(z.string(), z.string()).optional(),
+    })
+    .optional(),
+  shadcnComponents: z.array(z.string()).optional(),
+  dependsOn: z.array(z.string()).optional(),
+  smallLogo: z.string().optional(),
+  logo: z.string().optional(),
+  addOnSpecialSteps: z.array(z.string()).optional(),
+  createSpecialSteps: z.array(z.string()).optional(),
+})
+
+export const StarterSchema = AddOnBaseSchema.extend({
+  framework: z.string(),
+  mode: z.string(),
+  typescript: z.boolean(),
+  tailwind: z.boolean(),
+  banner: z.string().optional(),
+})
+
+export const StarterCompiledSchema = StarterSchema.extend({
+  files: z.record(z.string(), z.string()),
+  deletedFiles: z.array(z.string()),
+})
+
+export const IntegrationSchema = z.object({
+  type: z.string(),
+  path: z.string(),
+  jsName: z.string(),
+})
+
+export const AddOnInfoSchema = AddOnBaseSchema.extend({
+  modes: z.array(z.string()),
+  integrations: z.array(IntegrationSchema).optional(),
+  phase: z.enum(['setup', 'add-on']),
+  readme: z.string().optional(),
+})
+
+export const AddOnCompiledSchema = AddOnInfoSchema.extend({
+  files: z.record(z.string(), z.string()),
+  deletedFiles: z.array(z.string()),
+})
+
+export type Integration = z.infer<typeof IntegrationSchema>
+
+export type AddOnBase = z.infer<typeof AddOnBaseSchema>
+
+export type StarterInfo = z.infer<typeof StarterSchema>
+
+export type StarterCompiled = z.infer<typeof StarterCompiledSchema>
+
+export type AddOnInfo = z.infer<typeof AddOnInfoSchema>
+
+export type AddOnCompiled = z.infer<typeof AddOnCompiledSchema>
+
 export type FileBundleHandler = {
   getFiles: () => Promise<Array<string>>
   getFileContents: (path: string) => Promise<string>
+  getDeletedFiles: () => Promise<Array<string>>
 }
 
-export type Integration = {
-  type: 'provider' | 'root-provider' | 'layout' | 'header-user'
-  path: string
-  jsName: string
-}
-
-export type AddOnDefinition = {
-  id: string
-  name: string
-  description: string
-  type: 'add-on' | 'example' | 'starter' | 'toolchain'
-  link: string
-  templates: Array<string>
-  routes?: Array<{
-    url: string
-    name: string
-    path: string
-    jsName: string
-  }>
-  packageAdditions: {
-    dependencies?: Record<string, string>
-    devDependencies?: Record<string, string>
-    scripts?: Record<string, string>
-  }
-  command?: {
-    command: string
-    args?: Array<string>
-  }
-  readme?: string
-  phase: 'setup' | 'add-on'
-  shadcnComponents?: Array<string>
-  warning?: string
-  dependsOn?: Array<string>
-  integrations?: Array<Integration>
-  variables?: Array<Variable>
-
-  files?: Record<string, string>
-  deletedFiles?: Array<string>
-}
-
-export type StarterDefinition = AddOnDefinition & {
-  type: 'starter'
-  version: string
-  author: string
-  link: string
-  license: string
-  mode: Mode
-  framework: string
-  typescript: boolean
-  tailwind: boolean
-}
+export type AddOn = AddOnInfo & FileBundleHandler
 
-export type AddOn = AddOnDefinition & FileBundleHandler
-export type Starter = StarterDefinition & FileBundleHandler
+export type Starter = StarterCompiled & FileBundleHandler
 
 export type FrameworkDefinition = {
   id: string
@@ -85,17 +126,29 @@ export type Framework = FrameworkDefinition &
   }
 
 export interface Options {
-  framework: Framework
   projectName: string
+  targetDir: string
+
+  framework: Framework
+  mode: Mode
+
   typescript: boolean
   tailwind: boolean
+
   packageManager: PackageManager
-  mode: Mode
-  addOns: boolean
-  chosenAddOns: Array<AddOn>
   git: boolean
-  variableValues: Record<string, string | number | boolean>
-  starter?: AddOn | undefined
+
+  chosenAddOns: Array<AddOn>
+  starter?: Starter | undefined
+}
+
+export type SerializedOptions = Omit<
+  Options,
+  'chosenAddOns' | 'starter' | 'framework'
+> & {
+  chosenAddOns: Array<string>
+  starter?: string | undefined
+  framework: string
 }
 
 type ProjectEnvironment = {
@@ -108,12 +161,40 @@ type FileEnvironment = {
   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>
+  writeFileBase64: (path: string, base64Contents: string) => Promise<void>
+  execute: (
+    command: string,
+    args: Array<string>,
+    cwd: string,
+  ) => Promise<{ stdout: string }>
   deleteFile: (path: string) => Promise<void>
+
   exists: (path: string) => boolean
+  isDirectory: (path: string) => boolean
+  readFile: (path: string) => Promise<string>
+  readdir: (path: string) => Promise<Array<string>>
+  rimraf: (path: string) => Promise<void>
+}
+
+export type StatusEvent = {
+  id: string
+  type: StatusStepType
+  message: string
+}
+export type StopEvent = {
+  id: string
 }
 
 type UIEnvironment = {
+  appName: string
+
+  startStep: (info: {
+    id: string
+    type: StatusStepType
+    message: string
+  }) => void
+  finishStep: (id: string, finalMessage: string) => void
+
   intro: (message: string) => void
   outro: (message: string) => void
 
@@ -129,26 +210,3 @@ type UIEnvironment = {
 }
 
 export type Environment = ProjectEnvironment & FileEnvironment & UIEnvironment
-
-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'
-}
-
-export type Variable = BooleanVariable | NumberVariable | StringVariable

package/tests/add-ons.test.ts

@@ -13,12 +13,12 @@ describe('getAllAddOns', () => {
           {
             id: 'add-on-1',
             description: 'Add-on 1',
-            templates: ['file-router'],
+            modes: ['file-router'],
           } as AddOn,
           {
             id: 'add-on-2',
             description: 'Add-on 2',
-            templates: ['code-router'],
+            modes: ['code-router'],
           } as AddOn,
         ],
       } as Framework,
@@ -39,18 +39,18 @@ describe('finalizeAddOns', () => {
           {
             id: 'add-on-1',
             description: 'Add-on 1',
-            templates: ['file-router'],
+            modes: ['file-router'],
             dependsOn: ['add-on-2'],
           } as AddOn,
           {
             id: 'add-on-2',
             description: 'Add-on 2',
-            templates: ['file-router'],
+            modes: ['file-router'],
           } as AddOn,
           {
             id: 'add-on-3',
             description: 'Add-on 3',
-            templates: ['file-router'],
+            modes: ['file-router'],
           } as AddOn,
         ],
       } as Framework,