@tanstack/cta-engine 0.27.1 → 0.29.0

package/dist/add-ons.js

@@ -33,3 +33,16 @@ export async function finalizeAddOns(framework, mode, chosenAddOnIDs) {
 function loadAddOn(addOn) {
     return addOn;
 }
+export function populateAddOnOptionsDefaults(chosenAddOns) {
+    const addOnOptions = {};
+    for (const addOn of chosenAddOns) {
+        if (addOn.options) {
+            const defaults = {};
+            for (const [optionKey, optionDef] of Object.entries(addOn.options)) {
+                defaults[optionKey] = optionDef.default;
+            }
+            addOnOptions[addOn.id] = defaults;
+        }
+    }
+    return addOnOptions;
+}

package/dist/add-to-app.js

@@ -108,7 +108,9 @@ export async function runNewCommands(environment, originalOptions, cwd, output)
                 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');
         }
     }
@@ -158,6 +160,18 @@ export async function addToApp(environment, addOns, cwd, options) {
     await packageManagerInstall(environment, newOptions.targetDir, newOptions.packageManager);
     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([]);
+    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);
     environment.startStep({

package/dist/create-app.js

@@ -109,6 +109,16 @@ async function runCommandsAndInstallDependencies(environment, options) {
     await packageManagerInstall(environment, options.targetDir, options.packageManager);
     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([]);
+    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) => addOn.phase === phase && addOn.command && addOn.command.command)) {
             s.start(`Running commands for ${addOn.name}...`);
@@ -121,7 +131,7 @@ async function runCommandsAndInstallDependencies(environment, options) {
                 type: 'command',
                 message: cmd,
             });
-            await environment.execute(addOn.command.command, addOn.command.args || [], options.targetDir);
+            await environment.execute(addOn.command.command, addOn.command.args || [], options.targetDir, { inherit: true });
             environment.finishStep('run-commands', 'Setup commands complete');
             s.stop(`${addOn.name} commands complete`);
         }
@@ -140,7 +150,7 @@ async function runCommandsAndInstallDependencies(environment, options) {
             type: 'command',
             message: cmd,
         });
-        await environment.execute(options.starter.command.command, options.starter.command.args || [], options.targetDir);
+        await environment.execute(options.starter.command.command, options.starter.command.args || [], options.targetDir, { inherit: true });
         environment.finishStep('run-starter-command', 'Starter command complete');
         s.stop(`${options.starter.name} commands complete`);
     }
@@ -172,7 +182,7 @@ Use the following commands to start your app:
 % cd ${options.projectName}
 % ${formatCommand(getPackageManagerScriptCommand(options.packageManager, ['dev']))}
 
-Please check the README.md for information on testing, styling, adding routes, etc.${errorStatement}`);
+Please read the README.md for information on testing, styling, adding routes, etc.${errorStatement}`);
 }
 export async function createApp(environment, options) {
     environment.startRun();

package/dist/custom-add-ons/shared.js

@@ -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';
@@ -44,6 +44,9 @@ export async function createAppOptionsFromPersisted(json) {
     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,
@@ -55,9 +58,8 @@ export async function createAppOptionsFromPersisted(json) {
         targetDir: '',
         framework: framework,
         starter: json.starter ? await loadStarter(json.starter) : undefined,
-        chosenAddOns: await finalizeAddOns(framework, json.mode, [
-            ...json.chosenAddOns,
-        ]),
+        chosenAddOns,
+        addOnOptions: populateAddOnOptionsDefaults(chosenAddOns),
     };
 }
 export function createSerializedOptionsFromPersisted(json) {
@@ -75,6 +77,7 @@ export function createSerializedOptionsFromPersisted(json) {
         targetDir: '',
         framework: json.framework,
         starter: json.starter,
+        addOnOptions: {},
     };
 }
 export async function runCreateApp(options) {

package/dist/environment.js

@@ -29,12 +29,23 @@ export function createDefaultEnvironment() {
             await mkdir(dirname(path), { recursive: true });
             return writeFile(path, getBinaryFile(base64Contents));
         },
-        execute: async (command, args, cwd) => {
+        execute: async (command, args, cwd, options) => {
             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/dist/frameworks.js

@@ -29,9 +29,13 @@ export function scanAddOnDirectories(addOnsDirectories) {
             const fileContent = readFileSync(filePath, 'utf-8');
             const info = JSON.parse(fileContent);
             let packageAdditions = {};
+            let packageTemplate = 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;
             if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
                 readme = readFileSync(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
@@ -59,6 +63,7 @@ export function scanAddOnDirectories(addOnsDirectories) {
                 ...info,
                 id: dir,
                 packageAdditions,
+                packageTemplate,
                 readme,
                 files,
                 smallLogo,

package/dist/index.js

@@ -1,6 +1,6 @@
 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';
 export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';

package/dist/package-json.js

@@ -1,7 +1,9 @@
+import { render } from 'ejs';
 import { sortObject } from './utils.js';
 export function mergePackageJSON(packageJSON, overlayPackageJSON) {
     return {
         ...packageJSON,
+        ...(overlayPackageJSON || {}),
         dependencies: {
             ...packageJSON.dependencies,
             ...(overlayPackageJSON?.dependencies || {}),
@@ -33,8 +35,36 @@ export function createPackageJSON(options) {
     for (const addition of additions.filter(Boolean)) {
         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((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) {
         packageJSON = mergePackageJSON(packageJSON, options.starter.packageAdditions);

package/dist/special-steps/index.js

@@ -1,13 +1,15 @@
 import { rimrafNodeModules } from './rimraf-node-modules.js';
+import { postInitScript } from './post-init-script.js';
 const specialStepsLookup = {
     'rimraf-node-modules': rimrafNodeModules,
+    'post-init-script': postInitScript,
 };
 export async function runSpecialSteps(environment, options, specialSteps) {
     if (specialSteps.length) {
         environment.startStep({
             id: 'special-steps',
             type: 'command',
-            message: 'Removing node_modules...',
+            message: 'Running special steps...',
         });
         for (const step of specialSteps) {
             const stepFunction = specialStepsLookup[step];

package/dist/special-steps/post-init-script.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getPackageManagerScriptCommand } from '../package-manager.js';
+export async function postInitScript(environment, 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/dist/template-file.js

@@ -59,6 +59,7 @@ export function createTemplateFile(environment, options) {
             fileRouter: options.mode === 'file-router',
             codeRouter: options.mode === 'code-router',
             addOnEnabled,
+            addOnOption: options.addOnOptions,
             addOns: options.chosenAddOns,
             integrations,
             routes,
@@ -91,6 +92,12 @@ export function createTemplateFile(environment, options) {
             return;
         }
         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/dist/types/add-ons.d.ts

@@ -1,3 +1,4 @@
 import type { AddOn, Framework } from './types.js';
 export declare function getAllAddOns(framework: Framework, mode: string): Array<AddOn>;
 export declare function finalizeAddOns(framework: Framework, mode: string, chosenAddOnIDs: Array<string>): Promise<Array<AddOn>>;
+export declare function populateAddOnOptionsDefaults(chosenAddOns: Array<AddOn>): Record<string, Record<string, any>>;

package/dist/types/custom-add-ons/add-on.d.ts

@@ -12,16 +12,27 @@ export declare function validateAddOnSetup(environment: Environment): Promise<vo
 export declare function readOrGenerateAddOnInfo(options: PersistedOptions): Promise<AddOnInfo>;
 export declare function generateProject(persistedOptions: PersistedOptions): Promise<{
     info: {
+        type: "add-on" | "example" | "starter" | "toolchain" | "host";
+        description: string;
         id: string;
         name: string;
-        description: string;
-        type: "add-on" | "example" | "starter" | "toolchain" | "host";
         modes: string[];
         phase: "add-on" | "setup";
         command?: {
             command: string;
             args?: string[] | undefined;
         } | undefined;
+        options?: Record<string, {
+            type: "select";
+            options: {
+                value: string;
+                label: string;
+            }[];
+            label: string;
+            default: string;
+            description?: string | undefined;
+        }> | undefined;
+        default?: boolean | undefined;
         author?: string | undefined;
         version?: string | undefined;
         link?: string | undefined;
@@ -44,7 +55,7 @@ export declare function generateProject(persistedOptions: PersistedOptions): Pro
         logo?: string | undefined;
         addOnSpecialSteps?: string[] | undefined;
         createSpecialSteps?: string[] | undefined;
-        default?: boolean | undefined;
+        postInitSpecialSteps?: string[] | undefined;
         integrations?: {
             type?: string | undefined;
             code?: string | undefined;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 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';
 export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
@@ -16,6 +16,6 @@ export { createAppOptionsFromPersisted, createSerializedOptionsFromPersisted, }
 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, Options, SerializedOptions, Starter, StarterCompiled, } from './types.js';
+export type { AddOn, AddOnOption, AddOnOptions, AddOnSelectOption, AddOnSelection, Environment, FileBundleHandler, Framework, FrameworkDefinition, Options, SerializedOptions, Starter, StarterCompiled, } from './types.js';
 export type { PersistedOptions } from './config-file.js';
 export type { PackageManager } from './package-manager.js';

package/dist/types/registry.d.ts

@@ -9,15 +9,15 @@ declare const registrySchema: z.ZodObject<{
         mode: z.ZodString;
         framework: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         mode: string;
         banner?: string | undefined;
     }, {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         mode: string;
@@ -30,46 +30,46 @@ declare const registrySchema: z.ZodObject<{
         modes: z.ZodArray<z.ZodString, "many">;
         framework: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         modes: string[];
     }, {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         modes: string[];
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     starters?: {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         mode: string;
         banner?: string | undefined;
     }[] | undefined;
     'add-ons'?: {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         modes: string[];
     }[] | undefined;
 }, {
     starters?: {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         mode: string;
         banner?: string | undefined;
     }[] | undefined;
     'add-ons'?: {
-        name: string;
         description: string;
+        name: string;
         url: string;
         framework: string;
         modes: string[];

package/dist/types/special-steps/post-init-script.d.ts

@@ -0,0 +1,2 @@
+import type { Environment, Options } from '../types.js';
+export declare function postInitScript(environment: Environment, options: Options): Promise<void>;