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

package/dist/package-json.js

@@ -18,7 +18,6 @@ function mergePackageJSON(packageJSON, overlayPackageJSON) {
     };
 }
 export function createPackageJSON(options) {
-    const addOns = options.chosenAddOns.map((addOn) => addOn.packageAdditions);
     let packageJSON = {
         ...JSON.parse(JSON.stringify(options.framework.basePackageJSON)),
         name: options.projectName,
@@ -37,10 +36,10 @@ export function createPackageJSON(options) {
     for (const addition of additions.filter(Boolean)) {
         packageJSON = mergePackageJSON(packageJSON, addition);
     }
-    for (const addOn of addOns) {
+    for (const addOn of options.chosenAddOns.map((addOn) => addOn.packageAdditions)) {
         packageJSON = mergePackageJSON(packageJSON, addOn);
     }
-    packageJSON.dependencies = sortObject(packageJSON.dependencies);
-    packageJSON.devDependencies = sortObject(packageJSON.devDependencies);
+    packageJSON.dependencies = sortObject((packageJSON.dependencies ?? {}));
+    packageJSON.devDependencies = sortObject((packageJSON.devDependencies ?? {}));
     return packageJSON;
 }

package/dist/template-file.js

@@ -3,7 +3,7 @@ import { render } from 'ejs';
 import { format } from 'prettier';
 import { CODE_ROUTER, FILE_ROUTER } from './constants.js';
 import { formatCommand } from './utils.js';
-import { getPackageManagerExecuteCommand, getPackageManagerInstallCommand, } from './package-manager.js';
+import { getPackageManagerInstallCommand, getPackageManagerScriptCommand, } from './package-manager.js';
 import { relativePath } from './file-helpers.js';
 function convertDotFilesAndPaths(path) {
     return path
@@ -15,8 +15,11 @@ export function createTemplateFile(environment, options, targetDir) {
     function getPackageManagerAddScript(packageName, isDev = false) {
         return formatCommand(getPackageManagerInstallCommand(options.packageManager, packageName, isDev));
     }
-    function getPackageManagerRunScript(scriptName) {
-        return formatCommand(getPackageManagerExecuteCommand(options.packageManager, scriptName));
+    function getPackageManagerRunScript(scriptName, args = []) {
+        return formatCommand(getPackageManagerScriptCommand(options.packageManager, [
+            scriptName,
+            ...args,
+        ]));
     }
     class IgnoreFileError extends Error {
         constructor() {
@@ -38,6 +41,19 @@ export function createTemplateFile(environment, options, targetDir) {
             routes.push(...addOn.routes);
         }
     }
+    const variables = {
+        ...options.variableValues,
+        ...options.chosenAddOns.reduce((acc, addOn) => {
+            return {
+                ...acc,
+                ...addOn.variables,
+            };
+        }, {}),
+    };
+    const addOnEnabled = options.chosenAddOns.reduce((acc, addOn) => {
+        acc[addOn.id] = true;
+        return acc;
+    }, {});
     return async function templateFile(file, content) {
         const templateValues = {
             packageManager: options.packageManager,
@@ -48,13 +64,11 @@ export function createTemplateFile(environment, options, targetDir) {
             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;
-            }, {}),
+            addOnEnabled,
             addOns: options.chosenAddOns,
             integrations,
             routes,
+            variables,
             getPackageManagerAddScript,
             getPackageManagerRunScript,
             relativePath: (path) => relativePath(file, path),

package/dist/types/types.d.ts

@@ -6,6 +6,11 @@ export type FileBundleHandler = {
     getFiles: () => Promise<Array<string>>;
     getFileContents: (path: string) => Promise<string>;
 };
+export type Integration = {
+    type: 'provider' | 'root-provider' | 'layout' | 'header-user';
+    path: string;
+    jsName: string;
+};
 export type AddOnDefinition = {
     id: string;
     name: string;
@@ -33,11 +38,7 @@ export type AddOnDefinition = {
     shadcnComponents?: Array<string>;
     warning?: string;
     dependsOn?: Array<string>;
-    integrations?: Array<{
-        type: 'provider' | 'root-provider' | 'layout' | 'header-user';
-        path: string;
-        jsName: string;
-    }>;
+    integrations?: Array<Integration>;
     variables?: Array<Variable>;
     files?: Record<string, string>;
     deletedFiles?: Array<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/cta-engine",
-  "version": "0.10.0-alpha.16",
+  "version": "0.10.0-alpha.18",
   "description": "Tanstack Application Builder Engine",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,6 +31,7 @@
     "@tanstack/config": "^0.16.2",
     "@types/ejs": "^3.1.5",
     "@types/node": "^22.13.4",
+    "@vitest/coverage-v8": "3.1.1",
     "eslint": "^9.20.0",
     "typescript": "^5.6.3",
     "vitest": "^3.0.8"

package/src/package-json.ts

@@ -25,8 +25,6 @@ function mergePackageJSON(
 }
 
 export function createPackageJSON(options: Options) {
-  const addOns = options.chosenAddOns.map((addOn) => addOn.packageAdditions)
-
   let packageJSON = {
     ...JSON.parse(JSON.stringify(options.framework.basePackageJSON)),
     name: options.projectName,
@@ -47,15 +45,17 @@ export function createPackageJSON(options: Options) {
     packageJSON = mergePackageJSON(packageJSON, addition!)
   }
 
-  for (const addOn of addOns) {
+  for (const addOn of options.chosenAddOns.map(
+    (addOn) => addOn.packageAdditions,
+  )) {
     packageJSON = mergePackageJSON(packageJSON, addOn)
   }
 
   packageJSON.dependencies = sortObject(
-    packageJSON.dependencies as Record<string, string>,
+    (packageJSON.dependencies ?? {}) as Record<string, string>,
   )
   packageJSON.devDependencies = sortObject(
-    packageJSON.devDependencies as Record<string, string>,
+    (packageJSON.devDependencies ?? {}) as Record<string, string>,
   )
 
   return packageJSON

package/src/template-file.ts

@@ -5,8 +5,8 @@ import { format } from 'prettier'
 import { CODE_ROUTER, FILE_ROUTER } from './constants.js'
 import { formatCommand } from './utils.js'
 import {
-  getPackageManagerExecuteCommand,
   getPackageManagerInstallCommand,
+  getPackageManagerScriptCommand,
 } from './package-manager.js'
 import { relativePath } from './file-helpers.js'
 
@@ -36,9 +36,15 @@ export function createTemplateFile(
       ),
     )
   }
-  function getPackageManagerRunScript(scriptName: string) {
+  function getPackageManagerRunScript(
+    scriptName: string,
+    args: Array<string> = [],
+  ) {
     return formatCommand(
-      getPackageManagerExecuteCommand(options.packageManager, scriptName),
+      getPackageManagerScriptCommand(options.packageManager, [
+        scriptName,
+        ...args,
+      ]),
     )
   }
 
@@ -65,6 +71,24 @@ 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
+      return acc
+    },
+    {},
+  )
+
   return async function templateFile(file: string, content: string) {
     const templateValues = {
       packageManager: options.packageManager,
@@ -75,16 +99,11 @@ export function createTemplateFile(
       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
-        },
-        {},
-      ),
+      addOnEnabled,
       addOns: options.chosenAddOns,
       integrations,
       routes,
+      variables,
 
       getPackageManagerAddScript,
       getPackageManagerRunScript,

package/src/types.ts

@@ -10,6 +10,12 @@ export type FileBundleHandler = {
   getFileContents: (path: string) => Promise<string>
 }
 
+export type Integration = {
+  type: 'provider' | 'root-provider' | 'layout' | 'header-user'
+  path: string
+  jsName: string
+}
+
 export type AddOnDefinition = {
   id: string
   name: string
@@ -37,11 +43,7 @@ export type AddOnDefinition = {
   shadcnComponents?: Array<string>
   warning?: string
   dependsOn?: Array<string>
-  integrations?: Array<{
-    type: 'provider' | 'root-provider' | 'layout' | 'header-user'
-    path: string
-    jsName: string
-  }>
+  integrations?: Array<Integration>
   variables?: Array<Variable>
 
   files?: Record<string, string>

package/tests/add-ons.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+
+import { finalizeAddOns, getAllAddOns } from '../src/add-ons.js'
+
+import type { AddOn, Framework } from '../src/types.js'
+
+describe('getAllAddOns', () => {
+  it('filter add-ons', () => {
+    const addOns = getAllAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'add-on-1',
+            description: 'Add-on 1',
+            templates: ['file-router'],
+          } as AddOn,
+          {
+            id: 'add-on-2',
+            description: 'Add-on 2',
+            templates: ['code-router'],
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+    )
+
+    expect(addOns.length).toEqual(1)
+    expect(addOns[0].id).toEqual('add-on-1')
+  })
+})
+
+describe('finalizeAddOns', () => {
+  it('should finalize add-ons', async () => {
+    const addOns = await finalizeAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'add-on-1',
+            description: 'Add-on 1',
+            templates: ['file-router'],
+            dependsOn: ['add-on-2'],
+          } as AddOn,
+          {
+            id: 'add-on-2',
+            description: 'Add-on 2',
+            templates: ['file-router'],
+          } as AddOn,
+          {
+            id: 'add-on-3',
+            description: 'Add-on 3',
+            templates: ['file-router'],
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+      ['add-on-1'],
+    )
+
+    expect(addOns.length).toEqual(2)
+    const addOnIds = addOns.map((a) => a.id)
+    expect(addOnIds.includes('add-on-1')).toEqual(true)
+    expect(addOnIds.includes('add-on-2')).toEqual(true)
+    expect(addOnIds.includes('add-on-3')).toEqual(false)
+  })
+})

package/tests/config-file.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+import { resolve } from 'node:path'
+
+import { writeConfigFile } from '../src/config-file.js'
+import { CONFIG_FILE } from '../src/constants.js'
+
+import type { AddOn, Environment, Framework, Options } from '../src/types.js'
+
+describe('writeConfigFile', () => {
+  it('should write the config file', async () => {
+    const options = {
+      framework: {
+        id: 'react-cra',
+        getAddOns: () => [],
+      } as unknown as Framework,
+      chosenAddOns: [
+        {
+          id: 'add-on-1',
+          description: 'Add-on 1',
+          templates: ['file-router'],
+        } as AddOn,
+      ],
+      addOns: [],
+    } as unknown as Options
+    const targetDir = 'test-dir'
+    const persistedOptions = {
+      version: 1,
+      framework: options.framework.id,
+      existingAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+    }
+    const env = {
+      writeFile: (path, optionsString) => {
+        expect(path).toEqual(resolve(targetDir, CONFIG_FILE))
+        expect(optionsString).toEqual(JSON.stringify(persistedOptions, null, 2))
+      },
+    } as Environment
+    await writeConfigFile(env, targetDir, options)
+  })
+})

package/tests/create-app.test.ts

@@ -0,0 +1,145 @@
+import { resolve } from 'node:path'
+
+import { describe, expect, it } from 'vitest'
+
+import { createApp } from '../src/create-app.js'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { FILE_ROUTER } from '../src/constants.js'
+import { AddOn, Options } from '../src/types.js'
+
+const simpleOptions = {
+  projectName: 'test',
+  framework: {
+    id: 'test',
+    name: 'Test',
+    basePackageJSON: {
+      scripts: {
+        dev: 'react-scripts start',
+      },
+    },
+    optionalPackages: {
+      typescript: {
+        devDependencies: {
+          typescript: '^5.0.0',
+        },
+      },
+      tailwindcss: {
+        dependencies: {
+          tailwindcss: '^3.0.0',
+        },
+      },
+      'file-router': {
+        dependencies: {
+          'file-router': '^1.0.0',
+        },
+      },
+    },
+    getFiles: () => ['./src/test.txt'],
+    getFileContents: () => 'Hello',
+  },
+  chosenAddOns: [],
+  packageManager: 'pnpm',
+  typescript: true,
+  tailwind: true,
+  mode: FILE_ROUTER,
+  variableValues: {},
+} as unknown as Options
+
+describe('createApp', () => {
+  it('should create an app', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    await createApp(simpleOptions, {
+      silent: true,
+      environment,
+      name: 'Test',
+      cwd: '/',
+      appName: 'TanStack App',
+    })
+
+    expect(output.files['/src/test.txt']).toEqual('Hello')
+  })
+
+  it('should create an app - not silent', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    await createApp(simpleOptions, {
+      silent: false,
+      environment,
+      name: 'Test',
+      cwd: '/foo/bar/baz',
+      appName: 'TanStack App',
+    })
+
+    const cwd = process.cwd()
+
+    expect(output.files[resolve(cwd, '/foo/bar/baz/src/test.txt')]).toEqual(
+      'Hello',
+    )
+  })
+
+  it('should create an app - with a starter', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    await createApp(
+      {
+        ...simpleOptions,
+        starter: {
+          command: {
+            command: 'echo',
+            args: ['Hello'],
+          },
+          getFiles: () => ['./src/test2.txt'],
+          getFileContents: () => 'Hello-2',
+        } as unknown as AddOn,
+      },
+      {
+        silent: false,
+        environment,
+        name: 'Test',
+        cwd: '/',
+        appName: 'TanStack App',
+      },
+    )
+
+    expect(output.files['/src/test2.txt']).toEqual('Hello-2')
+    expect(output.commands.some(({ command }) => command === 'echo')).toBe(true)
+  })
+
+  it('should create an app - with a add-on', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    await createApp(
+      {
+        ...simpleOptions,
+        git: true,
+        addOns: true,
+        chosenAddOns: [
+          {
+            type: 'add-on',
+            phase: 'add-on',
+            warning: 'This is a warning',
+            command: {
+              command: 'echo',
+              args: ['Hello'],
+            },
+            packageAdditions: {
+              dependencies: {},
+              devDependencies: {},
+            },
+            getFiles: () => ['./src/test2.txt', './public/foo.jpg'],
+            getFileContents: () => 'base64::aGVsbG8=',
+          } as unknown as AddOn,
+        ],
+      },
+      {
+        silent: false,
+        environment,
+        name: 'Test',
+        cwd: '/',
+        appName: 'TanStack App',
+      },
+    )
+
+    console.log(output.commands)
+    expect(output.files['/src/test2.txt']).toEqual('hello')
+    expect(output.commands.some(({ command }) => command === 'echo')).toBe(true)
+  })
+})

package/tests/environment.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+
+describe('createMemoryEnvironment', () => {
+  it('should handle basic file operations', async () => {
+    const { environment, output } = createMemoryEnvironment()
+
+    environment.startRun()
+    await environment.writeFile('/test.txt', 'test')
+    environment.finishRun()
+
+    expect(output.files['/test.txt']).toEqual('test')
+  })
+
+  it('should track command execution', async () => {
+    const { environment, output } = createMemoryEnvironment()
+
+    environment.startRun()
+    await environment.execute('echo', ['test'], '')
+    environment.finishRun()
+
+    expect(output.commands.length).toEqual(1)
+    expect(output.commands[0].command).toEqual('echo')
+    expect(output.commands[0].args).toEqual(['test'])
+  })
+})

package/tests/integrations/git.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../../src/environment.js'
+import { setupGit } from '../../src/integrations/git.js'
+
+describe('git', () => {
+  it('should create a git repository', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    environment.startRun()
+    await setupGit(environment, '/test')
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'git',
+        args: ['init'],
+      },
+    ])
+  })
+})

package/tests/integrations/shadcn.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../../src/environment.js'
+import { installShadcnComponents } from '../../src/integrations/shadcn.js'
+
+import type { Options } from '../../src/types.js'
+
+describe('shadcn', () => {
+  it('should skip if no components are selected', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    environment.startRun()
+    await installShadcnComponents(
+      environment,
+      '/test',
+      {
+        packageManager: 'pnpm',
+        chosenAddOns: [],
+        projectName: 'test',
+        typescript: true,
+        spinner: () => ({
+          start: () => {},
+          succeed: () => {},
+          fail: () => {},
+        }),
+      } as unknown as Options,
+      true,
+    )
+    environment.finishRun()
+
+    expect(output.commands).toEqual([])
+  })
+
+  it('should add shadcn components for add-ons', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    environment.startRun()
+    await installShadcnComponents(
+      environment,
+      '/test',
+      {
+        packageManager: 'pnpm',
+        chosenAddOns: [
+          {
+            id: 'shadcn',
+            shadcnComponents: ['button'],
+          },
+          {
+            id: 'test-1',
+            shadcnComponents: ['button', 'card'],
+          },
+        ],
+        projectName: 'test',
+        typescript: true,
+        spinner: () => ({
+          start: () => {},
+          succeed: () => {},
+          fail: () => {},
+        }),
+      } as unknown as Options,
+      false,
+    )
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'pnpx',
+        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
+      },
+    ])
+  })
+
+  it('should add shadcn components in the starter', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    environment.startRun()
+    await installShadcnComponents(
+      environment,
+      '/test',
+      {
+        packageManager: 'pnpm',
+        chosenAddOns: [
+          {
+            id: 'shadcn',
+          },
+        ],
+        projectName: 'test',
+        typescript: true,
+        starter: {
+          shadcnComponents: ['button', 'card'],
+        },
+        spinner: () => ({
+          start: () => {},
+          succeed: () => {},
+          fail: () => {},
+        }),
+      } as unknown as Options,
+      false,
+    )
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'pnpx',
+        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
+      },
+    ])
+  })
+})

package/tests/package-json.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+
+import { createPackageJSON } from '../src/package-json.js'
+import { FILE_ROUTER } from '../src/constants.js'
+
+import type { Options, Framework } from '../src/types.js'
+
+describe('createPackageJSON', () => {
+  it('should create a package.json', () => {
+    const packageJSON = createPackageJSON({
+      chosenAddOns: [
+        {
+          packageAdditions: {
+            scripts: {
+              dev: 'file-router dev',
+            },
+          },
+        },
+      ],
+      mode: FILE_ROUTER,
+      typescript: true,
+      tailwind: true,
+      projectName: 'test',
+      framework: {
+        basePackageJSON: {},
+        optionalPackages: {
+          typescript: {
+            devDependencies: {
+              typescript: '^5.0.0',
+            },
+          },
+          tailwindcss: {
+            dependencies: {
+              tailwindcss: '^3.0.0',
+            },
+          },
+          'file-router': {
+            dependencies: {
+              'file-router': '^1.0.0',
+            },
+          },
+        },
+      } as unknown as Framework,
+    } as unknown as Options)
+
+    const expected = {
+      name: 'test',
+      dependencies: {
+        'file-router': '^1.0.0',
+        tailwindcss: '^3.0.0',
+      },
+      devDependencies: {
+        typescript: '^5.0.0',
+      },
+      scripts: {
+        dev: 'file-router dev',
+      },
+    }
+
+    // Use JSON.stringify to test sorting order of dependencies
+    expect(JSON.stringify(packageJSON)).toEqual(JSON.stringify(expected))
+  })
+})

package/tests/template-file.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { createTemplateFile } from '../src/template-file.js'
+import { FILE_ROUTER } from '../src/constants.js'
+
+import type { AddOn, Integration, Options } from '../src/types.js'
+
+const simpleOptions = {
+  projectName: 'test',
+  framework: {
+    id: 'test',
+    name: 'Test',
+  },
+  chosenAddOns: [],
+  packageManager: 'pnpm',
+  typescript: true,
+  tailwind: true,
+  mode: FILE_ROUTER,
+  variableValues: {
+    a: 'foo',
+  },
+} as unknown as Options
+
+describe('createTemplateFile', () => {
+  it('should template a simple file', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions, '/test')
+    environment.startRun()
+    await templateFile('./test.ts', 'let a = 1')
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts'].trim()).toEqual('let a = 1')
+  })
+
+  it('should template a simple file with ejs', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+        variableValues: {
+          a: 'foo',
+        },
+      } as unknown as Options,
+      '/test',
+    )
+    environment.startRun()
+    await templateFile('./test.ts.ejs', "let a = '<%= variables.a %>'")
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts'].trim()).toEqual("let a = 'foo'")
+  })
+
+  it('should handle ignore files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+      } as unknown as Options,
+      '/test',
+    )
+    environment.startRun()
+    await templateFile('./test.ts.ejs', '<% ignoreFile() %>let a = 1')
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts']).toBeUndefined()
+  })
+
+  it('should handle append files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions, '/test')
+    environment.startRun()
+    await templateFile('./test.txt.ejs', 'Line 1\n')
+    await templateFile('./test.txt.append', 'Line 2\n')
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Line 1\nLine 2\n')
+  })
+
+  it('should handle enabled add-ons', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+        chosenAddOns: [
+          {
+            id: 'test1',
+            name: 'Test 1',
+          },
+          {
+            id: 'test2',
+            name: 'Test 2',
+          },
+        ] as Array<AddOn>,
+      },
+      '/test',
+    )
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "Addons: <%= Object.keys(addOnEnabled).join(', ') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Addons: test1, test2')
+  })
+
+  it('should handle relative paths', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions, '/test')
+    environment.startRun()
+    await templateFile(
+      './src/test/test.txt.ejs',
+      "import { foo } from '<%= relativePath('./foo.ts') %>'",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/src/test/test.txt']).toEqual(
+      "import { foo } from '../../foo.ts'",
+    )
+  })
+
+  it('should handle routes', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+        chosenAddOns: [
+          {
+            id: 'test',
+            name: 'Test',
+            routes: [
+              {
+                path: '/test',
+                name: 'Test',
+                url: '/test',
+                jsName: 'test',
+              },
+            ],
+          } as AddOn,
+        ],
+      },
+      '/test',
+    )
+
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "<%= routes.map((route) => route.url).join(', ') %>",
+    )
+    environment.finishRun()
+
+    console.log(output.files['/test/test.txt'])
+
+    expect(output.files['/test/test.txt']).toEqual('/test')
+  })
+
+  it('should handle integrations', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+        chosenAddOns: [
+          {
+            id: 'test',
+            name: 'Test',
+            integrations: [
+              {
+                type: 'header-user',
+                path: '/test',
+                jsName: 'test',
+              } as Integration,
+            ],
+          } as AddOn,
+        ],
+      },
+      '/test',
+    )
+
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "<%= integrations.map((integration) => integration.path).join(', ') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('/test')
+  })
+
+  it('should handle package manager', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions, '/test')
+    environment.startRun()
+    await templateFile(
+      './foo.txt.ejs',
+      "<%= getPackageManagerAddScript('foo') %>",
+    )
+    await templateFile(
+      './foo-dev.txt.ejs',
+      "<%= getPackageManagerAddScript('foo', true) %>",
+    )
+    await templateFile(
+      './run-dev.txt.ejs',
+      "<%= getPackageManagerRunScript('dev') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/foo.txt']).toEqual('pnpm add foo')
+    expect(output.files['/test/foo-dev.txt']).toEqual('pnpm add foo --dev')
+    expect(output.files['/test/run-dev.txt']).toEqual('pnpm dev')
+  })
+})

package/tests/utils.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { formatCommand, jsSafeName, sortObject } from '../src/utils.js'
+
+describe('formatCommand', () => {
+  it('should format a command', () => {
+    expect(formatCommand({ command: 'echo', args: ['test'] })).toEqual(
+      'echo test',
+    )
+  })
+})
+
+describe('jsSafeName', () => {
+  it('should convert a string to a safe JS name', () => {
+    expect(jsSafeName('test.foo')).toEqual('TestFoo')
+  })
+})
+
+describe('sortObject', () => {
+  it('should sort an object', () => {
+    expect(sortObject({ b: 'b', a: 'a' })).toEqual({ a: 'a', b: 'b' })
+  })
+})