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

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/package-manager.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  getPackageManagerExecuteCommand,
+  getPackageManagerInstallCommand,
+  getPackageManagerScriptCommand,
+} from '../src/package-manager.js'
+import { formatCommand } from '../src/utils.js'
+
+describe('getPackageManagerScriptCommand', () => {
+  it('yarn', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('yarn', ['dev']))).toBe(
+      'yarn run dev',
+    )
+  })
+  it('pnpm', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('pnpm', ['dev']))).toBe(
+      'pnpm dev',
+    )
+  })
+  it('bun', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('bun', ['dev']))).toBe(
+      'bunx --bun run dev',
+    )
+  })
+  it('deno', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('deno', ['dev']))).toBe(
+      'deno task dev',
+    )
+  })
+  it('npm', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('npm', ['dev']))).toBe(
+      'npm run dev',
+    )
+  })
+})
+
+describe('getPackageManagerExecuteCommand', () => {
+  it('yarn', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('yarn', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('yarn dlx shadcn add button')
+  })
+  it('pnpm', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('pnpm', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('pnpx shadcn add button')
+  })
+  it('bun', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('bun', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('bunx --bun shadcn add button')
+  })
+  it('deno', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('deno', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('deno run npm:shadcn add button')
+  })
+  it('npm', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('npm', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('npx shadcn add button')
+  })
+})
+
+describe('getPackageManagerInstallCommand', () => {
+  it('yarn install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('yarn'))).toBe(
+      'yarn install',
+    )
+  })
+  it('pnpm install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('pnpm'))).toBe(
+      'pnpm install',
+    )
+  })
+  it('bun install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('bun'))).toBe(
+      'bun install',
+    )
+  })
+  it('deno install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('deno'))).toBe(
+      'deno install',
+    )
+  })
+  it('npm install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('npm'))).toBe(
+      'npm install',
+    )
+  })
+
+  it('yarn install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('yarn', 'radix-ui')),
+    ).toBe('yarn add radix-ui')
+  })
+  it('pnpm install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('pnpm', 'radix-ui')),
+    ).toBe('pnpm add radix-ui')
+  })
+  it('bun install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('bun', 'radix-ui')),
+    ).toBe('bun install radix-ui')
+  })
+  it('deno install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('deno', 'radix-ui')),
+    ).toBe('deno install radix-ui')
+  })
+  it('npm install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('npm', 'radix-ui')),
+    ).toBe('npm install radix-ui')
+  })
+
+  it('yarn install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('yarn', 'vitest', true)),
+    ).toBe('yarn add vitest --dev')
+  })
+  it('pnpm install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('pnpm', 'vitest', true)),
+    ).toBe('pnpm add vitest --dev')
+  })
+  it('bun install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('bun', 'vitest', true)),
+    ).toBe('bun install vitest -D')
+  })
+  it('deno install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('deno', 'vitest', true)),
+    ).toBe('deno install vitest -D')
+  })
+  it('npm install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('npm', 'vitest', true)),
+    ).toBe('npm install vitest -D')
+  })
+})

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' })
+  })
+})

package/dist/cli.js

@@ -1,125 +0,0 @@
-import { Command, InvalidArgumentError } from 'commander';
-import { intro, log } from '@clack/prompts';
-import { createApp } from './create-app.js';
-import { normalizeOptions, promptForOptions } from './options.js';
-import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
-import { SUPPORTED_TOOLCHAINS } from './toolchain.js';
-import runServer from './mcp.js';
-import { listAddOns } from './add-ons.js';
-import { DEFAULT_FRAMEWORK, SUPPORTED_FRAMEWORKS } from './constants.js';
-// import { initAddOn } from './custom-add-on.js'
-import { createDefaultEnvironment } from './environment.js';
-export function cli({ name, appName, forcedMode, forcedAddOns, }) {
-    const program = new Command();
-    program.name(name).description(`CLI to create a new ${appName} application`);
-    // program
-    //   .command('add')
-    //   .argument('add-on', 'Name of the add-on (or add-ons separated by commas)')
-    //   .action(async (addOn: string) => {
-    //     await add(addOn.split(',').map((addon) => addon.trim()))
-    //   })
-    // program
-    //   .command('update-add-on')
-    //   .description('Create or update an add-on from the current project')
-    //   .action(async () => {
-    //     await initAddOn('add-on')
-    //   })
-    // program
-    //   .command('update-overlay')
-    //   .description('Create or update a project overlay from the current project')
-    //   .action(async () => {
-    //     await initAddOn('overlay')
-    //   })
-    program.argument('[project-name]', 'name of the project');
-    if (!forcedMode) {
-        program.option('--template <type>', 'project template (typescript, javascript, file-router)', (value) => {
-            if (value !== 'typescript' &&
-                value !== 'javascript' &&
-                value !== 'file-router') {
-                throw new InvalidArgumentError(`Invalid template: ${value}. Only the following are allowed: typescript, javascript, file-router`);
-            }
-            return value;
-        });
-    }
-    program
-        .option('--framework <type>', 'project framework (solid, react)', (value) => {
-        if (!SUPPORTED_FRAMEWORKS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid framework: ${value}. Only the following are allowed: ${SUPPORTED_FRAMEWORKS.join(', ')}`);
-        }
-        return value;
-    }, DEFAULT_FRAMEWORK)
-        // .option('--overlay [url]', 'add an overlay from a URL', false)
-        .option(`--package-manager <${SUPPORTED_PACKAGE_MANAGERS.join('|')}>`, `Explicitly tell the CLI to use this package manager`, (value) => {
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid package manager: ${value}. The following are allowed: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
-        }
-        return value;
-    })
-        .option(`--toolchain <${SUPPORTED_TOOLCHAINS.join('|')}>`, `Explicitly tell the CLI to use this toolchain`, (value) => {
-        if (!SUPPORTED_TOOLCHAINS.includes(value)) {
-            throw new InvalidArgumentError(`Invalid toolchain: ${value}. The following are allowed: ${SUPPORTED_TOOLCHAINS.join(', ')}`);
-        }
-        return value;
-    })
-        .option('--tailwind', 'add Tailwind CSS', false)
-        .option('--add-ons [...add-ons]', 'pick from a list of available add-ons (comma separated list)', (value) => {
-        let addOns = !!value;
-        if (typeof value === 'string') {
-            addOns = value.split(',').map((addon) => addon.trim());
-        }
-        return addOns;
-    })
-        .option('--list-add-ons', 'list all available add-ons', false)
-        .option('--no-git', 'do not create a git repository')
-        .option('--target-dir <path>', 'the target directory for the application root')
-        .option('--mcp', 'run the MCP server', false)
-        .option('--mcp-sse', 'run the MCP server in SSE mode', false);
-    program.action(async (projectName, options) => {
-        if (options.listAddOns) {
-            await listAddOns(options, {
-                forcedMode: forcedMode,
-                forcedAddOns,
-            });
-        }
-        else if (options.mcp || options.mcpSse) {
-            await runServer(!!options.mcpSse, {
-                forcedMode: forcedMode,
-                forcedAddOns,
-                appName,
-            });
-        }
-        else {
-            try {
-                const cliOptions = {
-                    projectName,
-                    ...options,
-                };
-                if (forcedMode) {
-                    cliOptions.template = forcedMode;
-                }
-                let finalOptions = await normalizeOptions(cliOptions, forcedMode, forcedAddOns);
-                if (finalOptions) {
-                    intro(`Creating a new ${appName} app in ${projectName}...`);
-                }
-                else {
-                    intro(`Let's configure your ${appName} application`);
-                    finalOptions = await promptForOptions(cliOptions, {
-                        forcedMode: forcedMode,
-                        forcedAddOns,
-                    });
-                }
-                await createApp(finalOptions, {
-                    environment: createDefaultEnvironment(),
-                    cwd: options.targetDir || undefined,
-                    name,
-                    appName,
-                });
-            }
-            catch (error) {
-                log.error(error instanceof Error ? error.message : 'An unknown error occurred');
-                process.exit(1);
-            }
-        }
-    });
-    program.parse();
-}