@tanstack/cta-engine 0.10.0-alpha.18 → 0.10.0-alpha.20

package/dist/add-ons.js

@@ -1,10 +1,11 @@
-export function getAllAddOns(framework, template) {
-    return framework.getAddOns().filter((a) => a.templates.includes(template));
+import { loadRemoteAddOn } from './custom-add-ons/add-on.js';
+export function getAllAddOns(framework, mode) {
+    return framework.getAddOns().filter((a) => a.modes.includes(mode));
 }
 // Turn the list of chosen add-on IDs into a final list of add-ons by resolving dependencies
-export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
+export async function finalizeAddOns(framework, mode, chosenAddOnIDs) {
     const finalAddOnIDs = new Set(chosenAddOnIDs);
-    const addOns = getAllAddOns(framework, template);
+    const addOns = getAllAddOns(framework, mode);
     for (const addOnID of finalAddOnIDs) {
         let addOn;
         const localAddOn = addOns.find((a) => a.id === addOnID);
@@ -32,13 +33,3 @@ export async function finalizeAddOns(framework, template, chosenAddOnIDs) {
 function loadAddOn(addOn) {
     return addOn;
 }
-export async function loadRemoteAddOn(url) {
-    const response = await fetch(url);
-    const fileContent = await response.json();
-    fileContent.id = url;
-    return {
-        ...fileContent,
-        getFiles: () => Promise.resolve(Object.keys(fileContent.files)),
-        getFileContents: (path) => Promise.resolve(fileContent.files[path]),
-    };
-}

package/dist/add-to-app.js

@@ -1,23 +1,22 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync, statSync } from 'node:fs';
-import { basename, dirname, resolve } from 'node:path';
-import { execa, execaSync } from 'execa';
+import { basename, resolve } from 'node:path';
 import { CONFIG_FILE } from './constants.js';
 import { finalizeAddOns } from './add-ons.js';
 import { getFrameworkById } from './frameworks.js';
-import { createDefaultEnvironment, createMemoryEnvironment, } from './environment.js';
+import { createMemoryEnvironment } from './environment.js';
 import { createApp } from './create-app.js';
-import { readConfigFile, writeConfigFile } from './config-file.js';
-import { sortObject } from './utils.js';
-function isDirectory(path) {
-    return statSync(path).isDirectory();
+import { readConfigFileFromEnvironment, writeConfigFileToEnvironment, } from './config-file.js';
+import { formatCommand } from './utils.js';
+import { packageManagerInstall } from './package-manager.js';
+import { isBase64, recursivelyGatherFilesFromEnvironment, } from './file-helpers.js';
+import { mergePackageJSON } from './package-json.js';
+import { runSpecialSteps } from './special-steps/index.js';
+export async function hasPendingGitChanges(environment, cwd) {
+    const { stdout } = await environment.execute('git', ['status', '--porcelain'], cwd);
+    return stdout.length > 0;
 }
-async function hasPendingGitChanges() {
-    const status = await execaSync('git', ['status', '--porcelain']);
-    return status.stdout.length > 0;
-}
-async function createOptions(json, addOns) {
+async function createOptions(json, addOns, targetDir) {
     const framework = getFrameworkById(json.framework);
+    // TODO: Load the starter
     return {
         ...json,
         framework,
@@ -27,99 +26,144 @@ async function createOptions(json, addOns) {
             ...json.existingAddOns,
             ...addOns,
         ]),
+        targetDir,
     };
 }
 async function runCreateApp(options) {
-    const { environment, output } = createMemoryEnvironment();
-    await createApp(options, {
-        silent: true,
-        environment,
-        cwd: process.cwd(),
-        name: 'create-tsrouter-app',
-    });
+    const { environment, output } = createMemoryEnvironment(options.targetDir);
+    await createApp(environment, options);
     return output;
 }
-export async function addToApp(addOns, { silent = false, } = {}, environment) {
-    const persistedOptions = await readConfigFile(process.cwd());
+export async function getCurrentConfiguration(environment, cwd) {
+    const persistedOptions = await readConfigFileFromEnvironment(environment, 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.');
-        return;
-    }
-    if (!silent) {
-        environment.intro(`Adding ${addOns.join(', ')} to the project...`);
+        return undefined;
     }
-    if (await hasPendingGitChanges()) {
-        environment.error('You have pending git changes.', 'Please commit or stash them before adding add-ons.');
-        return;
-    }
-    const newOptions = await createOptions(persistedOptions, addOns);
-    const output = await runCreateApp(newOptions);
+    return persistedOptions;
+}
+export async function writeFiles(environment, cwd, output, forced) {
+    const currentFiles = await recursivelyGatherFilesFromEnvironment(environment, cwd, false);
     const overwrittenFiles = [];
     const changedFiles = [];
-    const contentMap = new Map();
     for (const file of Object.keys(output.files)) {
-        const relativeFile = file.replace(process.cwd(), '');
-        if (existsSync(file)) {
-            if (!isDirectory(file)) {
-                const contents = (await readFile(file)).toString();
-                if (['package.json', CONFIG_FILE].includes(basename(file)) ||
-                    contents !== output.files[file]) {
-                    overwrittenFiles.push(relativeFile);
-                    contentMap.set(relativeFile, output.files[file]);
-                }
+        const relativeFile = file.replace(cwd, '');
+        if (currentFiles[relativeFile]) {
+            if (currentFiles[relativeFile] !== output.files[file]) {
+                overwrittenFiles.push(relativeFile);
             }
         }
         else {
             changedFiles.push(relativeFile);
-            contentMap.set(relativeFile, output.files[file]);
         }
     }
-    if (overwrittenFiles.length > 0 && !silent) {
-        environment.warn('The following will be overwritten:', overwrittenFiles.join('\n'));
+    if (!forced && overwrittenFiles.length) {
+        environment.warn('The following will be overwritten:', [...overwrittenFiles, ...output.deletedFiles].join('\n'));
         const shouldContinue = await environment.confirm('Do you want to continue?');
         if (!shouldContinue) {
-            process.exit(0);
+            throw new Error('User cancelled');
         }
     }
+    for (const file of output.deletedFiles) {
+        if (environment.exists(resolve(cwd, file))) {
+            await environment.deleteFile(resolve(cwd, file));
+        }
+    }
+    environment.startStep({
+        id: 'write-files',
+        type: 'file',
+        message: 'Writing add-on files...',
+    });
     for (const file of [...changedFiles, ...overwrittenFiles]) {
-        const targetFile = `.${file}`;
         const fName = basename(file);
-        const contents = contentMap.get(file);
+        const contents = output.files[file];
         if (fName === 'package.json') {
-            const currentJson = JSON.parse((await readFile(resolve(fName), 'utf-8')).toString());
-            const newJson = JSON.parse(contents);
-            currentJson.scripts = newJson.scripts;
-            currentJson.dependencies = sortObject({
-                ...currentJson.dependencies,
-                ...newJson.dependencies,
-            });
-            currentJson.devDependencies = sortObject({
-                ...currentJson.devDependencies,
-                ...newJson.devDependencies,
-            });
-            await writeFile(targetFile, JSON.stringify(currentJson, null, 2));
+            const currentJson = JSON.parse(await environment.readFile(resolve(cwd, file)));
+            const newJSON = mergePackageJSON(currentJson, JSON.parse(contents));
+            environment.writeFile(resolve(cwd, file), JSON.stringify(newJSON, null, 2));
         }
         else if (fName !== CONFIG_FILE) {
-            await mkdir(resolve(dirname(targetFile)), { recursive: true });
-            await writeFile(resolve(targetFile), contents);
+            if (isBase64(contents)) {
+                await environment.writeFileBase64(resolve(cwd, file), contents);
+            }
+            else {
+                await environment.writeFile(resolve(cwd, file), contents);
+            }
         }
     }
-    // Handle commands
-    const originalOutput = await runCreateApp(await createOptions(persistedOptions, []));
+    environment.finishStep('write-files', 'Add-on files written');
+}
+export async function runNewCommands(environment, originalOptions, cwd, output) {
+    const originalOutput = await runCreateApp({
+        ...(await createOptions(originalOptions, [], cwd)),
+    });
     const originalCommands = new Set(originalOutput.commands.map((c) => [c.command, ...c.args].join(' ')));
     for (const command of output.commands) {
         const commandString = [command.command, ...command.args].join(' ');
         if (!originalCommands.has(commandString)) {
-            await execa(command.command, command.args);
+            environment.startStep({
+                id: 'run-commands',
+                type: 'command',
+                message: `Running ${formatCommand({ command: command.command, args: command.args })}...`,
+            });
+            await environment.execute(command.command, command.args, cwd);
+            environment.finishStep('run-commands', 'Setup commands complete');
+        }
+    }
+}
+export async function addToApp(environment, addOns, cwd, options) {
+    const persistedOptions = await getCurrentConfiguration(environment, cwd);
+    if (!persistedOptions) {
+        return;
+    }
+    if (!options?.forced && (await hasPendingGitChanges(environment, cwd))) {
+        environment.error('You have pending git changes.', 'Please commit or stash them before adding add-ons.');
+        return;
+    }
+    environment.intro(`Adding ${addOns.join(', ')} to the project...`);
+    environment.startStep({
+        id: 'processing-new-app-setup',
+        type: 'file',
+        message: 'Processing new app setup...',
+    });
+    const newOptions = await createOptions(persistedOptions, addOns, cwd);
+    const output = await runCreateApp({
+        ...newOptions,
+        targetDir: cwd,
+    });
+    await writeFiles(environment, cwd, output, !!options?.forced);
+    environment.finishStep('processing-new-app-setup', 'Application files written');
+    // Run any special steps for the new add-ons
+    const specialSteps = new Set([]);
+    for (const addOn of newOptions.chosenAddOns) {
+        for (const step of addOn.addOnSpecialSteps || []) {
+            if (addOns.includes(addOn.id)) {
+                specialSteps.add(step);
+            }
         }
     }
-    const realEnvironment = createDefaultEnvironment();
-    writeConfigFile(realEnvironment, process.cwd(), newOptions);
-    const s = silent ? null : environment.spinner();
-    s?.start(`Installing dependencies via ${newOptions.packageManager}...`);
-    await realEnvironment.execute(newOptions.packageManager, ['install'], resolve(process.cwd()));
-    s?.stop(`Installed dependencies`);
-    if (!silent) {
-        environment.outro('Add-ons added successfully!');
+    if (specialSteps.size) {
+        await runSpecialSteps(environment, newOptions, Array.from(specialSteps));
     }
+    // Install dependencies
+    environment.startStep({
+        id: 'install-dependencies',
+        type: 'package-manager',
+        message: `Installing dependencies via ${newOptions.packageManager}...`,
+    });
+    const s = environment.spinner();
+    s.start(`Installing dependencies via ${newOptions.packageManager}...`);
+    await packageManagerInstall(environment, newOptions.targetDir, newOptions.packageManager);
+    s.stop(`Installed dependencies`);
+    environment.finishStep('install-dependencies', 'Dependencies installed');
+    // Handle new commands
+    await runNewCommands(environment, persistedOptions, cwd, output);
+    environment.startStep({
+        id: 'write-config-file',
+        type: 'file',
+        message: 'Writing config file...',
+    });
+    writeConfigFileToEnvironment(environment, newOptions);
+    environment.finishStep('write-config-file', 'Config file written');
+    environment.outro('Add-ons added successfully!');
 }

package/dist/config-file.js

@@ -1,22 +1,24 @@
-import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { CONFIG_FILE } from './constants.js';
-export async function writeConfigFile(environment, targetDir, options) {
+function createPersistedOptions(options) {
     /* eslint-disable unused-imports/no-unused-vars */
-    const { addOns, chosenAddOns, framework, ...rest } = options;
+    const { chosenAddOns, framework, targetDir, ...rest } = options;
     /* eslint-enable unused-imports/no-unused-vars */
-    const persistedOptions = {
+    return {
         ...rest,
         version: 1,
         framework: options.framework.id,
         existingAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+        starter: options.starter?.id ?? undefined,
     };
-    await environment.writeFile(resolve(targetDir, CONFIG_FILE), JSON.stringify(persistedOptions, null, 2));
 }
-export async function readConfigFile(targetDir) {
+export async function writeConfigFileToEnvironment(environment, options) {
+    await environment.writeFile(resolve(options.targetDir, CONFIG_FILE), JSON.stringify(createPersistedOptions(options), null, 2));
+}
+export async function readConfigFileFromEnvironment(environment, targetDir) {
     try {
         const configFile = resolve(targetDir, CONFIG_FILE);
-        const config = await readFile(configFile, 'utf8');
+        const config = await environment.readFile(configFile);
         // TODO: Look for old config files and convert them to the new format
         return JSON.parse(config);
     }

package/dist/create-app.js

@@ -1,71 +1,152 @@
 import { basename, resolve } from 'node:path';
-import { getBinaryFile } from './file-helpers.js';
+import { isBase64 } from './file-helpers.js';
 import { formatCommand } from './utils.js';
-import { writeConfigFile } from './config-file.js';
+import { writeConfigFileToEnvironment } from './config-file.js';
 import { getPackageManagerScriptCommand, packageManagerInstall, } from './package-manager.js';
 import { createPackageJSON } from './package-json.js';
 import { createTemplateFile } from './template-file.js';
 import { installShadcnComponents } from './integrations/shadcn.js';
 import { setupGit } from './integrations/git.js';
-async function writeFiles(environment, targetDir, options) {
-    const templateFileFromContent = createTemplateFile(environment, options, targetDir);
+import { runSpecialSteps } from './special-steps/index.js';
+async function writeFiles(environment, options) {
+    const templateFileFromContent = createTemplateFile(environment, options);
     async function writeFileBundle(bundle) {
         const files = await bundle.getFiles();
         for (const file of files) {
             const contents = await bundle.getFileContents(file);
-            const binaryFile = getBinaryFile(contents);
-            if (binaryFile) {
-                await environment.writeFile(resolve(targetDir, file), binaryFile);
+            const isBinaryFile = isBase64(contents);
+            if (isBinaryFile) {
+                await environment.writeFileBase64(resolve(options.targetDir, file), contents);
             }
             else {
                 await templateFileFromContent(file, contents);
             }
         }
+        const deletedFiles = await bundle.getDeletedFiles();
+        for (const file of deletedFiles) {
+            await environment.deleteFile(resolve(options.targetDir, file));
+        }
     }
+    environment.startStep({
+        id: 'write-framework-files',
+        type: 'file',
+        message: 'Writing framework files...',
+    });
     await writeFileBundle(options.framework);
+    environment.finishStep('write-framework-files', 'Framework files written');
+    let wroteAddonFiles = false;
     for (const type of ['add-on', 'example', 'toolchain']) {
         for (const phase of ['setup', 'add-on', 'example']) {
             for (const addOn of options.chosenAddOns.filter((addOn) => addOn.phase === phase && addOn.type === type)) {
+                environment.startStep({
+                    id: 'write-addon-files',
+                    type: 'file',
+                    message: `Writing ${addOn.name} files...`,
+                });
                 await writeFileBundle(addOn);
+                wroteAddonFiles = true;
             }
         }
     }
+    if (wroteAddonFiles) {
+        environment.finishStep('write-addon-files', 'Add-on files written');
+    }
     if (options.starter) {
+        environment.startStep({
+            id: 'write-starter-files',
+            type: 'file',
+            message: 'Writing starter files...',
+        });
         await writeFileBundle(options.starter);
+        environment.finishStep('write-starter-files', 'Starter files written');
     }
-    await environment.writeFile(resolve(targetDir, './package.json'), JSON.stringify(createPackageJSON(options), null, 2));
-    await writeConfigFile(environment, targetDir, options);
+    environment.startStep({
+        id: 'write-package-json',
+        type: 'file',
+        message: 'Writing package.json...',
+    });
+    await environment.writeFile(resolve(options.targetDir, './package.json'), JSON.stringify(createPackageJSON(options), null, 2));
+    environment.finishStep('write-package-json', 'Package.json written');
+    environment.startStep({
+        id: 'write-config-file',
+        type: 'file',
+        message: 'Writing config file...',
+    });
+    await writeConfigFileToEnvironment(environment, options);
+    environment.finishStep('write-config-file', 'Config file written');
 }
-async function runCommandsAndInstallDependencies(environment, targetDir, options, silent) {
-    const s = silent ? null : environment.spinner();
+async function runCommandsAndInstallDependencies(environment, options) {
+    const s = environment.spinner();
     // Setup git
     if (options.git) {
-        s?.start(`Initializing git repository...`);
-        await setupGit(environment, targetDir);
-        s?.stop(`Initialized git repository`);
+        s.start(`Initializing git repository...`);
+        environment.startStep({
+            id: 'initialize-git-repository',
+            type: 'command',
+            message: 'Initializing git repository...',
+        });
+        await setupGit(environment, options.targetDir);
+        environment.finishStep('initialize-git-repository', 'Initialized git repository');
+        s.stop(`Initialized git repository`);
+    }
+    // Run any special steps for the new add-ons
+    const specialSteps = new Set([]);
+    for (const addOn of options.chosenAddOns) {
+        for (const step of addOn.createSpecialSteps || []) {
+            specialSteps.add(step);
+        }
+    }
+    if (specialSteps.size) {
+        await runSpecialSteps(environment, options, Array.from(specialSteps));
     }
     // Install dependencies
-    s?.start(`Installing dependencies via ${options.packageManager}...`);
-    await packageManagerInstall(environment, resolve(targetDir), options.packageManager);
-    s?.stop(`Installed dependencies`);
+    s.start(`Installing dependencies via ${options.packageManager}...`);
+    environment.startStep({
+        id: 'install-dependencies',
+        type: 'package-manager',
+        message: `Installing dependencies via ${options.packageManager}...`,
+    });
+    await packageManagerInstall(environment, options.targetDir, options.packageManager);
+    environment.finishStep('install-dependencies', 'Installed dependencies');
+    s.stop(`Installed dependencies`);
     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(`Setting up ${addOn.name}...`);
-            await environment.execute(addOn.command.command, addOn.command.args || [], resolve(targetDir));
-            s?.stop(`${addOn.name} setup complete`);
+            s.start(`Running commands for ${addOn.name}...`);
+            const cmd = formatCommand({
+                command: addOn.command.command,
+                args: addOn.command.args || [],
+            });
+            environment.startStep({
+                id: 'run-commands',
+                type: 'command',
+                message: cmd,
+            });
+            await environment.execute(addOn.command.command, addOn.command.args || [], options.targetDir);
+            environment.finishStep('run-commands', 'Setup commands complete');
+            s.stop(`${addOn.name} commands complete`);
         }
     }
     // Adding starter
     if (options.starter &&
         options.starter.command &&
         options.starter.command.command) {
-        s?.start(`Setting up starter ${options.starter.name}...`);
-        await environment.execute(options.starter.command.command, options.starter.command.args || [], resolve(targetDir));
-        s?.stop(`Starter ${options.starter.name} setup complete`);
+        s.start(`Setting up starter ${options.starter.name}...`);
+        const cmd = formatCommand({
+            command: options.starter.command.command,
+            args: options.starter.command.args || [],
+        });
+        environment.startStep({
+            id: 'run-starter-command',
+            type: 'command',
+            message: cmd,
+        });
+        await environment.execute(options.starter.command.command, options.starter.command.args || [], options.targetDir);
+        environment.finishStep('run-starter-command', 'Starter command complete');
+        s.stop(`${options.starter.name} commands complete`);
     }
-    await installShadcnComponents(environment, targetDir, options, silent);
+    await installShadcnComponents(environment, options.targetDir, options);
 }
-function report(environment, options, appName, targetDir) {
+function report(environment, options) {
     const warnings = [];
     for (const addOn of options.chosenAddOns) {
         if (addOn.warning) {
@@ -84,7 +165,7 @@ Errors were encountered during this process:
 
 ${environment.getErrors().join('\n')}`;
     }
-    environment.outro(`Your ${appName} app is ready in '${basename(targetDir)}'.
+    environment.outro(`Your ${environment.appName} app is ready in '${basename(options.targetDir)}'.
 
 Use the following commands to start your app:
 % cd ${options.projectName}
@@ -92,22 +173,10 @@ Use the following commands to start your app:
 
   Please check the README.md for more information on testing, styling, adding routes, etc.${errorStatement}`);
 }
-export async function createApp(options, { silent = false, environment, cwd, appName = 'TanStack', }) {
+export async function createApp(environment, options) {
     environment.startRun();
-    let targetDir = cwd || '';
-    if (!targetDir.length) {
-        targetDir = resolve(process.cwd(), options.projectName);
-        if (environment.exists(targetDir)) {
-            if (!silent) {
-                environment.error(`Directory "${options.projectName}" already exists`);
-            }
-            return;
-        }
-    }
-    await writeFiles(environment, targetDir, options);
-    await runCommandsAndInstallDependencies(environment, targetDir, options, silent);
+    await writeFiles(environment, options);
+    await runCommandsAndInstallDependencies(environment, options);
     environment.finishRun();
-    if (!silent) {
-        report(environment, options, appName, targetDir);
-    }
+    report(environment, options);
 }