@tanstack/cta-engine 0.28.0 → 0.29.0

package/dist/types.js

@@ -1,4 +1,18 @@
 import z from 'zod';
+export const AddOnSelectOptionSchema = z.object({
+    type: z.literal('select'),
+    label: z.string(),
+    description: z.string().optional(),
+    default: z.string(),
+    options: z.array(z.object({
+        value: z.string(),
+        label: z.string(),
+    })),
+});
+export const AddOnOptionSchema = z.discriminatedUnion('type', [
+    AddOnSelectOptionSchema,
+]);
+export const AddOnOptionsSchema = z.record(z.string(), AddOnOptionSchema);
 export const AddOnBaseSchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -36,6 +50,8 @@ export const AddOnBaseSchema = z.object({
     logo: z.string().optional(),
     addOnSpecialSteps: z.array(z.string()).optional(),
     createSpecialSteps: z.array(z.string()).optional(),
+    postInitSpecialSteps: z.array(z.string()).optional(),
+    options: AddOnOptionsSchema.optional(),
     default: z.boolean().optional(),
 });
 export const StarterSchema = AddOnBaseSchema.extend({
@@ -65,4 +81,5 @@ export const AddOnInfoSchema = AddOnBaseSchema.extend({
 export const AddOnCompiledSchema = AddOnInfoSchema.extend({
     files: z.record(z.string(), z.string()),
     deletedFiles: z.array(z.string()),
+    packageTemplate: z.string().optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/cta-engine",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Tanstack Application Builder Engine",
   "type": "module",
   "main": "./dist/index.js",

package/src/add-ons.ts

@@ -47,3 +47,21 @@ export async function finalizeAddOns(
 function loadAddOn(addOn: AddOn): AddOn {
   return addOn
 }
+
+export function populateAddOnOptionsDefaults(
+  chosenAddOns: Array<AddOn>
+): Record<string, Record<string, any>> {
+  const addOnOptions: Record<string, Record<string, any>> = {}
+  
+  for (const addOn of chosenAddOns) {
+    if (addOn.options) {
+      const defaults: Record<string, any> = {}
+      for (const [optionKey, optionDef] of Object.entries(addOn.options)) {
+        defaults[optionKey] = optionDef.default
+      }
+      addOnOptions[addOn.id] = defaults
+    }
+  }
+  
+  return addOnOptions
+}

package/src/add-to-app.ts

@@ -181,7 +181,9 @@ export async function runNewCommands(
         type: 'command',
         message: `Running ${formatCommand({ command: command.command, args: command.args })}...`,
       })
-      await environment.execute(command.command, command.args, cwd)
+      await environment.execute(command.command, command.args, cwd, {
+        inherit: true,
+      })
       environment.finishStep('run-commands', 'Setup commands complete')
     }
   }
@@ -260,6 +262,23 @@ export async function addToApp(
   s.stop(`Installed dependencies`)
   environment.finishStep('install-dependencies', 'Dependencies installed')
 
+  // Run any post-init special steps for the new add-ons
+  const postInitSpecialSteps = new Set<string>([])
+  for (const addOn of newOptions.chosenAddOns) {
+    for (const step of addOn.postInitSpecialSteps || []) {
+      if (addOns.includes(addOn.id)) {
+        postInitSpecialSteps.add(step)
+      }
+    }
+  }
+  if (postInitSpecialSteps.size) {
+    await runSpecialSteps(
+      environment,
+      newOptions,
+      Array.from(postInitSpecialSteps),
+    )
+  }
+
   // Handle new commands
 
   await runNewCommands(environment, persistedOptions, cwd, output)

package/src/create-app.ts

@@ -147,6 +147,21 @@ async function runCommandsAndInstallDependencies(
   environment.finishStep('install-dependencies', 'Installed dependencies')
   s.stop(`Installed dependencies`)
 
+  // Run any post-init special steps for the new add-ons
+  const postInitSpecialSteps = new Set<string>([])
+  for (const addOn of options.chosenAddOns) {
+    for (const step of addOn.postInitSpecialSteps || []) {
+      postInitSpecialSteps.add(step)
+    }
+  }
+  if (postInitSpecialSteps.size) {
+    await runSpecialSteps(
+      environment,
+      options,
+      Array.from(postInitSpecialSteps),
+    )
+  }
+
   for (const phase of ['setup', 'add-on', 'example']) {
     for (const addOn of options.chosenAddOns.filter(
       (addOn) =>
@@ -166,6 +181,7 @@ async function runCommandsAndInstallDependencies(
         addOn.command!.command,
         addOn.command!.args || [],
         options.targetDir,
+        { inherit: true },
       )
       environment.finishStep('run-commands', 'Setup commands complete')
       s.stop(`${addOn.name} commands complete`)
@@ -193,6 +209,7 @@ async function runCommandsAndInstallDependencies(
       options.starter.command.command,
       options.starter.command.args || [],
       options.targetDir,
+      { inherit: true },
     )
 
     environment.finishStep('run-starter-command', 'Starter command complete')

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

@@ -2,7 +2,7 @@ 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 { finalizeAddOns, populateAddOnOptionsDefaults } from '../add-ons.js'
 import { getFrameworkById } from '../frameworks.js'
 import { readConfigFileFromEnvironment } from '../config-file.js'
 import { readFileHelper } from '../file-helpers.js'
@@ -66,6 +66,9 @@ export async function createAppOptionsFromPersisted(
   const { version, ...rest } = json
   /* eslint-enable unused-imports/no-unused-vars */
   const framework = getFrameworkById(rest.framework)
+  const chosenAddOns = await finalizeAddOns(framework!, json.mode!, [
+    ...json.chosenAddOns,
+  ])
   return {
     ...rest,
     mode: json.mode!,
@@ -77,9 +80,8 @@ export async function createAppOptionsFromPersisted(
     targetDir: '',
     framework: framework!,
     starter: json.starter ? await loadStarter(json.starter) : undefined,
-    chosenAddOns: await finalizeAddOns(framework!, json.mode!, [
-      ...json.chosenAddOns,
-    ]),
+    chosenAddOns,
+    addOnOptions: populateAddOnOptionsDefaults(chosenAddOns),
   }
 }
 
@@ -100,6 +102,7 @@ export function createSerializedOptionsFromPersisted(
     targetDir: '',
     framework: json.framework,
     starter: json.starter,
+    addOnOptions: {},
   }
 }
 

package/src/environment.ts

@@ -46,12 +46,22 @@ export function createDefaultEnvironment(): Environment {
       await mkdir(dirname(path), { recursive: true })
       return writeFile(path, getBinaryFile(base64Contents) as string)
     },
-    execute: async (command: string, args: Array<string>, cwd: string) => {
+    execute: async (command: string, args: Array<string>, cwd: string, options?: { inherit?: boolean }) => {
       try {
-        const result = await execa(command, args, {
-          cwd,
-        })
-        return { stdout: result.stdout }
+        if (options?.inherit) {
+          // For commands that should show output directly to the user
+          await execa(command, args, {
+            cwd,
+            stdio: 'inherit',
+          })
+          return { stdout: '' }
+        } else {
+          // For commands where we need to capture output
+          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.`,

package/src/frameworks.ts

@@ -56,11 +56,15 @@ export function scanAddOnDirectories(addOnsDirectories: Array<string>) {
       const fileContent = readFileSync(filePath, 'utf-8')
       const info = JSON.parse(fileContent)
 
-      let packageAdditions: Record<string, string> = {}
+      let packageAdditions: Record<string, any> = {}
+      let packageTemplate: string | undefined = undefined
+      
       if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
         packageAdditions = JSON.parse(
           readFileSync(resolve(addOnsBase, dir, 'package.json'), 'utf-8'),
         )
+      } else if (existsSync(resolve(addOnsBase, dir, 'package.json.ejs'))) {
+        packageTemplate = readFileSync(resolve(addOnsBase, dir, 'package.json.ejs'), 'utf-8')
       }
 
       let readme: string | undefined
@@ -97,6 +101,7 @@ export function scanAddOnDirectories(addOnsDirectories: Array<string>) {
         ...info,
         id: dir,
         packageAdditions,
+        packageTemplate,
         readme,
         files,
         smallLogo,

package/src/index.ts

@@ -1,7 +1,7 @@
 export { createApp } from './create-app.js'
 export { addToApp } from './add-to-app.js'
 
-export { finalizeAddOns, getAllAddOns } from './add-ons.js'
+export { finalizeAddOns, getAllAddOns, populateAddOnOptionsDefaults } from './add-ons.js'
 
 export { loadRemoteAddOn } from './custom-add-ons/add-on.js'
 export { loadStarter } from './custom-add-ons/starter.js'
@@ -73,6 +73,10 @@ export {
 
 export type {
   AddOn,
+  AddOnOption,
+  AddOnOptions,
+  AddOnSelectOption,
+  AddOnSelection,
   Environment,
   FileBundleHandler,
   Framework,

package/src/package-json.ts

@@ -1,3 +1,4 @@
+import { render } from 'ejs'
 import { sortObject } from './utils.js'
 
 import type { Options } from './types.js'
@@ -8,6 +9,7 @@ export function mergePackageJSON(
 ) {
   return {
     ...packageJSON,
+    ...(overlayPackageJSON || {}),
     dependencies: {
       ...packageJSON.dependencies,
       ...(overlayPackageJSON?.dependencies || {}),
@@ -42,10 +44,44 @@ export function createPackageJSON(options: Options) {
     packageJSON = mergePackageJSON(packageJSON, addition)
   }
 
-  for (const addOn of options.chosenAddOns.map(
-    (addOn) => addOn.packageAdditions,
-  )) {
-    packageJSON = mergePackageJSON(packageJSON, addOn)
+  for (const addOn of options.chosenAddOns) {
+    let addOnPackageJSON = addOn.packageAdditions
+
+    // Process EJS template if present
+    if (addOn.packageTemplate) {
+      const templateValues = {
+        packageManager: options.packageManager,
+        projectName: options.projectName,
+        typescript: options.typescript,
+        tailwind: options.tailwind,
+        js: options.typescript ? 'ts' : 'js',
+        jsx: options.typescript ? 'tsx' : 'jsx',
+        fileRouter: options.mode === 'file-router',
+        codeRouter: options.mode === 'code-router',
+        addOnEnabled: options.chosenAddOns.reduce<Record<string, boolean>>(
+          (acc, addon) => {
+            acc[addon.id] = true
+            return acc
+          },
+          {},
+        ),
+        addOnOption: options.addOnOptions,
+        addOns: options.chosenAddOns,
+      }
+
+      try {
+        const renderedTemplate = render(addOn.packageTemplate, templateValues)
+        addOnPackageJSON = JSON.parse(renderedTemplate)
+      } catch (error) {
+        console.error(
+          `Error processing package.json.ejs for add-on ${addOn.id}:`,
+          error,
+        )
+        // Fall back to packageAdditions if template processing fails
+      }
+    }
+
+    packageJSON = mergePackageJSON(packageJSON, addOnPackageJSON)
   }
 
   if (options.starter) {

package/src/special-steps/index.ts

@@ -1,4 +1,5 @@
 import { rimrafNodeModules } from './rimraf-node-modules.js'
+import { postInitScript } from './post-init-script.js'
 
 import type { Environment, Options } from '../types.js'
 
@@ -7,6 +8,7 @@ const specialStepsLookup: Record<
   (environment: Environment, options: Options) => Promise<void>
 > = {
   'rimraf-node-modules': rimrafNodeModules,
+  'post-init-script': postInitScript,
 }
 
 export async function runSpecialSteps(
@@ -18,7 +20,7 @@ export async function runSpecialSteps(
     environment.startStep({
       id: 'special-steps',
       type: 'command',
-      message: 'Removing node_modules...',
+      message: 'Running special steps...',
     })
 
     for (const step of specialSteps) {

package/src/special-steps/post-init-script.ts

@@ -0,0 +1,52 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { getPackageManagerScriptCommand } from '../package-manager.js'
+
+import type { Environment, Options } from '../types.js'
+
+export async function postInitScript(
+  environment: Environment,
+  options: Options,
+) {
+  const packageJsonPath = resolve(options.targetDir, 'package.json')
+
+  if (!environment.exists(packageJsonPath)) {
+    environment.warn(
+      'Warning',
+      'No package.json found, skipping post-cta-init script',
+    )
+    return
+  }
+
+  try {
+    const packageJsonContent = readFileSync(packageJsonPath, 'utf-8')
+    const packageJson = JSON.parse(packageJsonContent)
+
+    if (!packageJson.scripts || !packageJson.scripts['post-cta-init']) {
+      // No post-cta-init script found, skip silently
+      return
+    }
+
+    environment.startStep({
+      id: 'post-init-script',
+      type: 'command',
+      message: 'Running post-cta-init script...',
+    })
+
+    const { command, args } = getPackageManagerScriptCommand(
+      options.packageManager,
+      ['post-cta-init'],
+    )
+
+    await environment.execute(command, args, options.targetDir, {
+      inherit: true,
+    })
+
+    environment.finishStep('post-init-script', 'Post-cta-init script complete')
+  } catch (error) {
+    environment.error(
+      `Failed to run post-cta-init script: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+}

package/src/template-file.ts

@@ -95,6 +95,7 @@ export function createTemplateFile(environment: Environment, options: Options) {
       fileRouter: options.mode === 'file-router',
       codeRouter: options.mode === 'code-router',
       addOnEnabled,
+      addOnOption: options.addOnOptions,
       addOns: options.chosenAddOns,
       integrations,
       routes,
@@ -135,6 +136,13 @@ export function createTemplateFile(environment: Environment, options: Options) {
 
     let target = convertDotFilesAndPaths(file.replace('.ejs', ''))
 
+    // Strip option prefixes from filename (e.g., __postgres__schema.prisma -> schema.prisma)
+    const prefixMatch = target.match(/^(.+\/)?__([^_]+)__(.+)$/)
+    if (prefixMatch) {
+      const [, directory, , filename] = prefixMatch
+      target = (directory || '') + filename
+    }
+
     let append = false
     if (target.endsWith('.append')) {
       append = true

package/src/types.ts

@@ -9,6 +9,25 @@ export type StatusStepType =
   | 'package-manager'
   | 'other'
 
+export const AddOnSelectOptionSchema = z.object({
+  type: z.literal('select'),
+  label: z.string(),
+  description: z.string().optional(),
+  default: z.string(),
+  options: z.array(
+    z.object({
+      value: z.string(),
+      label: z.string(),
+    }),
+  ),
+})
+
+export const AddOnOptionSchema = z.discriminatedUnion('type', [
+  AddOnSelectOptionSchema,
+])
+
+export const AddOnOptionsSchema = z.record(z.string(), AddOnOptionSchema)
+
 export const AddOnBaseSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -48,6 +67,8 @@ export const AddOnBaseSchema = z.object({
   logo: z.string().optional(),
   addOnSpecialSteps: z.array(z.string()).optional(),
   createSpecialSteps: z.array(z.string()).optional(),
+  postInitSpecialSteps: z.array(z.string()).optional(),
+  options: AddOnOptionsSchema.optional(),
   default: z.boolean().optional(),
 })
 
@@ -82,8 +103,15 @@ export const AddOnInfoSchema = AddOnBaseSchema.extend({
 export const AddOnCompiledSchema = AddOnInfoSchema.extend({
   files: z.record(z.string(), z.string()),
   deletedFiles: z.array(z.string()),
+  packageTemplate: z.string().optional(),
 })
 
+export type AddOnSelectOption = z.infer<typeof AddOnSelectOptionSchema>
+
+export type AddOnOption = z.infer<typeof AddOnOptionSchema>
+
+export type AddOnOptions = z.infer<typeof AddOnOptionsSchema>
+
 export type Integration = z.infer<typeof IntegrationSchema>
 
 export type AddOnBase = z.infer<typeof AddOnBaseSchema>
@@ -96,13 +124,19 @@ export type AddOnInfo = z.infer<typeof AddOnInfoSchema>
 
 export type AddOnCompiled = z.infer<typeof AddOnCompiledSchema>
 
+export interface AddOnSelection {
+  id: string
+  enabled: boolean
+  options: Record<string, any>
+}
+
 export type FileBundleHandler = {
   getFiles: () => Promise<Array<string>>
   getFileContents: (path: string) => Promise<string>
   getDeletedFiles: () => Promise<Array<string>>
 }
 
-export type AddOn = AddOnInfo & FileBundleHandler
+export type AddOn = AddOnCompiled & FileBundleHandler
 
 export type Starter = StarterCompiled & FileBundleHandler
 
@@ -146,6 +180,7 @@ export interface Options {
   git: boolean
 
   chosenAddOns: Array<AddOn>
+  addOnOptions: Record<string, Record<string, any>>
   starter?: Starter | undefined
 }
 
@@ -173,6 +208,7 @@ type FileEnvironment = {
     command: string,
     args: Array<string>,
     cwd: string,
+    options?: { inherit?: boolean },
   ) => Promise<{ stdout: string }>
   deleteFile: (path: string) => Promise<void>