@tanstack/cta-engine 0.10.0-alpha.21 → 0.10.0-alpha.25

package/tests/frameworks.test.ts

@@ -1,95 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-import {
-  getFrameworks,
-  getFrameworkById,
-  getFrameworkByName,
-  registerFramework,
-} from '../src/frameworks.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-})
-
-describe('registerFramework', () => {
-  it('should register a framework', async () => {
-    const addOnPackageJSON = {
-      id: 'test',
-      name: 'Test',
-      description: 'Test',
-      version: '1.0.0',
-    }
-    const basePackageJSON = {
-      name: 'Test',
-      version: '1.0.0',
-    }
-
-    vol.mkdirSync('/test/add-ons/test/assets', { recursive: true })
-    vol.writeFileSync(
-      '/test/add-ons/test/info.json',
-      JSON.stringify({
-        id: 'test',
-        name: 'Test',
-        description: 'Test',
-        version: '1.0.0',
-      }),
-    )
-    vol.writeFileSync(
-      '/test/add-ons/test/package.json',
-      JSON.stringify({
-        id: 'test',
-        name: 'Test',
-        description: 'Test',
-        version: '1.0.0',
-      }),
-    )
-    vol.writeFileSync(
-      '/test/add-ons/test/assets/package.json',
-      JSON.stringify(addOnPackageJSON),
-    )
-    vol.writeFileSync('/test/add-ons/test/README.md', 'foo')
-    vol.mkdirSync('/test/project/base/assets', { recursive: true })
-    vol.writeFileSync(
-      '/test/project/base/package.json',
-      JSON.stringify(basePackageJSON),
-    )
-    vol.writeFileSync(
-      '/test/project/packages.json',
-      JSON.stringify({
-        typescript: {},
-      }),
-    )
-
-    registerFramework({
-      id: 'test',
-      name: 'Test',
-      addOnsDirectories: ['/test/add-ons'],
-      description: 'Test',
-      version: '1.0.0',
-      baseDirectory: '/test/project',
-      examplesDirectory: '/test/examples',
-    })
-
-    const f = getFrameworkById('test')!
-
-    const baseFiles = await f.getFiles()
-    expect(baseFiles).toEqual(['./package.json'])
-
-    const fileContents = await f.getFileContents('./package.json')
-    expect(fileContents).toEqual(JSON.stringify(basePackageJSON))
-
-    const addOns = await f.getAddOns()
-    const addOnFiles = await addOns[0].getFiles()
-    expect(addOnFiles).toEqual(['./package.json'])
-
-    const addOnFileContents = await addOns[0].getFileContents('./package.json')
-    expect(addOnFileContents).toEqual(JSON.stringify(addOnPackageJSON))
-
-    expect(getFrameworkByName('Test')).not.toBeUndefined()
-    expect(getFrameworks().length).toEqual(1)
-  })
-})

package/tests/index.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createApp } from '../src/index.js'
-
-describe('index', () => {
-  it('should be a test', () => {
-    expect(createApp).toBeDefined()
-  })
-})

package/tests/integrations/git.test.ts

@@ -1,20 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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)
-    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)
-    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)
-    environment.finishRun()
-
-    expect(output.commands).toEqual([
-      {
-        command: 'pnpx',
-        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
-      },
-    ])
-  })
-})

package/tests/options.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createSerializedOptions } from '../src/options.js'
-import { AddOn, Framework, Options, Starter } from '../src/types.js'
-
-describe('createSerializedOptions', () => {
-  it('handle no add-ons', () => {
-    const options = createSerializedOptions({
-      framework: {
-        id: 'react-cra',
-      } as Framework,
-      chosenAddOns: [],
-    } as unknown as Options)
-    expect(options).toEqual({
-      framework: 'react-cra',
-      chosenAddOns: [],
-    })
-  })
-
-  it('handle add-ons and a starter', () => {
-    const options = createSerializedOptions({
-      framework: {
-        id: 'react-cra',
-      } as Framework,
-      chosenAddOns: [
-        {
-          id: 'add-on-1',
-          description: 'Add-on 1',
-          modes: ['file-router'],
-        } as AddOn,
-      ],
-      starter: {
-        id: 'starter-1',
-      } as unknown as Starter,
-    } as unknown as Options)
-    expect(options).toEqual({
-      framework: 'react-cra',
-      chosenAddOns: ['add-on-1'],
-      starter: 'starter-1',
-    })
-  })
-})

package/tests/package-json.test.ts

@@ -1,63 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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/setupVitest.ts

@@ -1,6 +0,0 @@
-import createFetchMock from 'vitest-fetch-mock'
-import { vi } from 'vitest'
-
-const fetchMocker = createFetchMock(vi)
-
-fetchMocker.enableMocks()

package/tests/template-file.test.ts

@@ -1,178 +0,0 @@
-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',
-  targetDir: '/test',
-  framework: {
-    id: 'test',
-    name: 'Test',
-  },
-  chosenAddOns: [],
-  packageManager: 'pnpm',
-  typescript: true,
-  tailwind: true,
-  mode: FILE_ROUTER,
-} as unknown as Options
-
-describe('createTemplateFile', () => {
-  it('should template a simple file', async () => {
-    const { environment, output } = createMemoryEnvironment()
-    const templateFile = createTemplateFile(environment, simpleOptions)
-    environment.startRun()
-    await templateFile('./test.ts', 'let a = 1')
-    environment.finishRun()
-
-    expect(output.files['/test/test.ts'].trim()).toEqual('let a = 1')
-  })
-
-  it('should handle ignore files', async () => {
-    const { environment, output } = createMemoryEnvironment()
-    const templateFile = createTemplateFile(environment, {
-      ...simpleOptions,
-    } as unknown as Options)
-    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)
-    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>,
-    })
-    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)
-    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,
-      ],
-    })
-
-    environment.startRun()
-    await templateFile(
-      './test.txt.ejs',
-      "<%= routes.map((route) => route.url).join(', ') %>",
-    )
-    environment.finishRun()
-
-    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,
-      ],
-    })
-
-    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)
-    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

@@ -1,23 +0,0 @@
-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' })
-  })
-})