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

package/tests/create-app.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { resolve } from 'node:path'
-
-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',
-  targetDir: '/',
-  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',
-    getDeletedFiles: () => [],
-  },
-  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(environment, simpleOptions)
-
-    expect(output.files['/src/test.txt']).toEqual('Hello')
-  })
-
-  it('should create an app - not silent', async () => {
-    const { environment, output } = createMemoryEnvironment()
-    await createApp(environment, {
-      ...simpleOptions,
-      targetDir: '/foo/bar/baz',
-    })
-
-    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(environment, {
-      ...simpleOptions,
-      starter: {
-        command: {
-          command: 'echo',
-          args: ['Hello'],
-        },
-        getFiles: () => ['./src/test2.txt'],
-        getFileContents: () => 'Hello-2',
-        getDeletedFiles: () => [],
-      } as unknown as AddOn,
-    })
-
-    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(environment, {
-      ...simpleOptions,
-      git: 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=',
-          getDeletedFiles: () => [],
-        } as unknown as AddOn,
-      ],
-    })
-
-    // This is ok, we convert to binary right at the end of the process
-    expect(output.files['/src/test2.txt']).toEqual('base64::aGVsbG8=')
-    expect(output.commands.some(({ command }) => command === 'echo')).toBe(true)
-  })
-})

package/tests/custom-add-ons/add-on.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { camelCase } from '../../src/custom-add-ons/add-on.js'
-
-describe('camelCase', () => {
-  it('should convert a string to camel case', () => {
-    expect(camelCase('test-case')).toBe('TestCase')
-    expect(camelCase('demo.test-case')).toBe('DemoTestCase')
-    expect(camelCase('demo/test-case')).toBe('DemoTestCase')
-    expect(camelCase('demo/test/case')).toBe('DemoTestCase')
-  })
-})

package/tests/custom-add-ons/shared.test.ts

@@ -1,257 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-import {
-  compareFilesRecursively,
-  createAppOptionsFromPersisted,
-  createPackageAdditions,
-  createSerializedOptionsFromPersisted,
-  readCurrentProjectOptions,
-} from '../../src/custom-add-ons/shared.js'
-import { createMemoryEnvironment } from '../../src/environment.js'
-import {
-  __testClearFrameworks,
-  __testRegisterFramework,
-} from '../../src/frameworks.js'
-
-import type { PersistedOptions } from '../../src/config-file.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-
-  const fakeFiles = {
-    './package.json': JSON.stringify({
-      name: 'test',
-      version: '1.0.0',
-      dependencies: {},
-    }),
-  }
-
-  __testClearFrameworks()
-  __testRegisterFramework({
-    id: 'test',
-    name: 'Test',
-    description: 'Test',
-    version: '1.0.0',
-    baseDirectory: '/foo',
-    addOnsDirectories: [],
-    examplesDirectory: '',
-    basePackageJSON: {},
-    optionalPackages: {},
-    getAddOns: () => [
-      {
-        id: 'test',
-        name: 'Test',
-        description: 'Test',
-        version: '1.0.0',
-        type: 'add-on',
-        phase: 'add-on',
-        modes: ['code-router', 'file-router'],
-        command: {
-          command: 'echo',
-          args: ['baz'],
-        },
-        packageAdditions: {
-          dependencies: {
-            'test-package': '1.0.0',
-          },
-        },
-        dependsOn: [],
-        getFiles: () => Promise.resolve(['./jack.txt']),
-        getFileContents: () => Promise.resolve('foo'),
-        getDeletedFiles: () => Promise.resolve([]),
-      },
-    ],
-    getFiles: () => Promise.resolve(Object.keys(fakeFiles)),
-    getFileContents: (path) => Promise.resolve(fakeFiles[path]),
-    getDeletedFiles: () => Promise.resolve([]),
-  })
-})
-
-describe('createAppOptionsFromPersisted', () => {
-  it('should create live options from persisted options', async () => {
-    const persistedOptions = {
-      projectName: 'test-project',
-      framework: 'test',
-      mode: 'code-router',
-      typescript: true,
-      tailwind: true,
-      git: true,
-      packageManager: 'npm',
-      targetDir: '',
-      starter: undefined,
-      chosenAddOns: [],
-      existingAddOns: [],
-      version: 1,
-    } as PersistedOptions
-    const appOptions = await createAppOptionsFromPersisted(persistedOptions)
-    expect(appOptions.framework.id).toEqual('test')
-    expect(appOptions.mode).toEqual('code-router')
-    expect(appOptions.typescript).toEqual(true)
-    expect(appOptions.tailwind).toEqual(true)
-    expect(appOptions.git).toEqual(true)
-    expect(appOptions.packageManager).toEqual('npm')
-    expect(appOptions.targetDir).toEqual('')
-    expect(appOptions.starter).toEqual(undefined)
-    expect(appOptions.chosenAddOns).toEqual([])
-    expect(appOptions.chosenAddOns).toEqual([])
-  })
-})
-
-describe('createSerializedOptionsFromPersisted', () => {
-  it('should create serialized options from persisted options', async () => {
-    const persistedOptions = {
-      projectName: 'test-project',
-      framework: 'test',
-      mode: 'code-router',
-      typescript: true,
-      tailwind: true,
-      git: true,
-      packageManager: 'npm',
-      targetDir: '',
-      starter: undefined,
-      chosenAddOns: [],
-      existingAddOns: [],
-      version: 1,
-    } as PersistedOptions
-    const appOptions =
-      await createSerializedOptionsFromPersisted(persistedOptions)
-    expect(appOptions.framework).toEqual('test')
-    expect(appOptions.mode).toEqual('code-router')
-    expect(appOptions.typescript).toEqual(true)
-    expect(appOptions.tailwind).toEqual(true)
-    expect(appOptions.git).toEqual(true)
-    expect(appOptions.packageManager).toEqual('npm')
-    expect(appOptions.targetDir).toEqual('')
-    expect(appOptions.starter).toEqual(undefined)
-    expect(appOptions.chosenAddOns).toEqual([])
-    expect(appOptions.chosenAddOns).toEqual([])
-  })
-})
-
-describe('createPackageAdditions', () => {
-  it('should handles scripts', () => {
-    const packageAdditions = createPackageAdditions(
-      {
-        scripts: {
-          dev: 'vinxi dev',
-        },
-      },
-      {
-        scripts: {
-          dev: 'vinxi dev',
-          foo: 'bar',
-        },
-      },
-    )
-    expect(packageAdditions).toEqual({
-      scripts: {
-        foo: 'bar',
-      },
-    })
-  })
-
-  it('should handles dependencies', () => {
-    const packageAdditions = createPackageAdditions(
-      {
-        dependencies: {
-          react: '^18.0.0',
-        },
-        devDependencies: {
-          'foo-dev-dependency': '^18.0.0',
-          'updated-dev-dependency': '^18.0.0',
-        },
-      },
-      {
-        dependencies: {
-          react: '^18.0.0',
-          'react-dom': '^20.0.0',
-        },
-        devDependencies: {
-          'foo-dev-dependency': '^18.0.0',
-          'bar-dev-dependency': '^18.0.0',
-          'updated-dev-dependency': '^20.0.0',
-        },
-      },
-    )
-    expect(packageAdditions).toEqual({
-      dependencies: {
-        'react-dom': '^20.0.0',
-      },
-      devDependencies: {
-        'bar-dev-dependency': '^18.0.0',
-        'updated-dev-dependency': '^20.0.0',
-      },
-    })
-  })
-})
-
-describe('readCurrentProjectOptions', () => {
-  it('should read the current project options', async () => {
-    const { environment } = createMemoryEnvironment()
-    environment.writeFile(
-      '.cta.json',
-      JSON.stringify({
-        projectName: 'test-project',
-        framework: 'test',
-        mode: 'code-router',
-        typescript: true,
-        tailwind: true,
-        git: true,
-        packageManager: 'npm',
-        targetDir: '',
-        starter: undefined,
-        chosenAddOns: [],
-        existingAddOns: [],
-        version: 1,
-      }),
-    )
-    const options = await readCurrentProjectOptions(environment)
-    expect(options).toEqual({
-      chosenAddOns: [],
-      existingAddOns: [],
-      framework: 'test',
-      git: true,
-      mode: 'code-router',
-      packageManager: 'npm',
-      projectName: 'test-project',
-      tailwind: true,
-      targetDir: '',
-      typescript: true,
-      version: 1,
-    })
-  })
-})
-
-describe('compareFilesRecursively', () => {
-  it('should compare files recursively', async () => {
-    vol.mkdirSync('/foo')
-    vol.writeFileSync('/foo/.gitignore', 'foo')
-    vol.writeFileSync('/foo/bar.txt', 'bar')
-    vol.writeFileSync('/foo/baz.txt', 'baz')
-    vol.writeFileSync('/foo/qux.txt', 'qux')
-    vol.mkdirSync('/foo/bar')
-    vol.writeFileSync('/foo/bar/baz.txt', 'baz')
-    vol.writeFileSync('/foo/bar/qux.txt', 'qux')
-    const changedFiles = {}
-    await compareFilesRecursively(
-      '/foo',
-      () => false,
-      {
-        '/foo/.gitignore': '.gitignore',
-        '/foo/bar.txt': 'bar',
-      },
-      changedFiles,
-    )
-    expect(changedFiles).toEqual({
-      '/foo/.gitignore': 'foo',
-      '/foo/bar/baz.txt': 'baz',
-      '/foo/bar/qux.txt': 'qux',
-      '/foo/baz.txt': 'baz',
-      '/foo/qux.txt': 'qux',
-    })
-  })
-})

package/tests/custom-add-ons/starter.test.ts

@@ -1,58 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-import { readOrGenerateStarterInfo } from '../../src/custom-add-ons/starter.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-})
-
-describe('readOrGenerateStarterInfo', () => {
-  it('should read the starter info', async () => {
-    const starterInfo = await readOrGenerateStarterInfo({
-      framework: 'test',
-      version: 1,
-      existingAddOns: [],
-      starter: undefined,
-      projectName: 'test',
-      mode: 'code-router',
-      typescript: true,
-      tailwind: true,
-      git: true,
-    })
-    expect(starterInfo.id).toEqual('test-starter')
-  })
-
-  it('should read the starter info', async () => {
-    fs.mkdirSync(process.cwd(), { recursive: true })
-    fs.writeFileSync(
-      'starter-info.json',
-      JSON.stringify({
-        framework: 'test',
-        version: 1,
-        existingAddOns: [],
-        starter: undefined,
-        name: 'test-starter',
-        mode: 'code-router',
-        typescript: true,
-        tailwind: true,
-        git: true,
-      }),
-    )
-    const starterInfo = await readOrGenerateStarterInfo({
-      framework: 'test',
-      version: 1,
-      existingAddOns: [],
-      starter: undefined,
-      projectName: 'test',
-      mode: 'code-router',
-      typescript: true,
-      tailwind: true,
-      git: true,
-    })
-    expect(starterInfo.name).toEqual('test-starter')
-  })
-})

package/tests/environment.test.ts

@@ -1,115 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-})
-
-import {
-  createMemoryEnvironment,
-  createDefaultEnvironment,
-} 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.deleteFile('/test.txt')
-    expect(environment.exists('/test.txt')).toBe(false)
-
-    await environment.writeFile('/test.txt', 'test')
-
-    environment.finishRun()
-
-    expect(output.files['/test.txt']).toEqual('test')
-  })
-
-  it('should remove empty directories', async () => {
-    const { environment, output } = createMemoryEnvironment()
-
-    environment.startRun()
-
-    await environment.writeFile('/test.txt', 'test')
-
-    await environment.writeFile('/foo/test1.txt', 'test')
-    await environment.writeFile('/foo/test2.txt', 'test')
-    environment.deleteFile('/foo/test1.txt')
-    environment.deleteFile('/foo/test2.txt')
-
-    await environment.writeFile('/bar/test1.txt', 'test')
-
-    environment.finishRun()
-
-    expect(Object.keys(output.files)).toEqual(['/test.txt', '/bar/test1.txt'])
-  })
-
-  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'])
-  })
-})
-
-describe('createDefaultEnvironment', () => {
-  it('should create a default environment', async () => {
-    const environment = createDefaultEnvironment()
-    expect(environment).toBeDefined()
-  })
-
-  it('should write to the file system', async () => {
-    const environment = createDefaultEnvironment()
-    environment.startRun()
-    await environment.writeFile('/test.txt', 'test')
-    await environment.appendFile('/test.txt', 'test2')
-    await environment.copyFile('/test.txt', '/test2.txt')
-    environment.finishRun()
-
-    expect(fs.readFileSync('/test.txt', 'utf8')).toEqual('testtest2')
-  })
-
-  it('should allow deletes', async () => {
-    const environment = createDefaultEnvironment()
-    await environment.writeFile('/test.txt', 'test')
-    expect(fs.readFileSync('/test.txt', 'utf8')).toEqual('test')
-    await environment.deleteFile('/test.txt')
-    expect(environment.exists('/test.txt')).toBe(false)
-  })
-
-  it('should record errors', async () => {
-    const environment = createDefaultEnvironment()
-    environment.startRun()
-    await environment.execute('command-that-does-not-exist', ['test'], '')
-    environment.finishRun()
-    expect(environment.getErrors()).toEqual([
-      'Command "command-that-does-not-exist test" did not run successfully. Please run this manually in your project.',
-    ])
-  })
-
-  it('should have UI methods', async () => {
-    const environment = createDefaultEnvironment()
-    environment.startRun()
-    environment.intro('test')
-    environment.outro('test')
-    environment.info('test')
-    environment.error('test')
-    environment.warn('test')
-    const s = environment.spinner()
-    s.start('foo')
-    s.stop('bar')
-    environment.finishRun()
-    expect(await environment.confirm('test')).toEqual(true)
-  })
-})

package/tests/file-helper.test.ts

@@ -1,90 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-import {
-  findFilesRecursively,
-  isDirectory,
-  readFileHelper,
-  relativePath,
-} from '../src/file-helpers.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-})
-
-describe('relativePath', () => {
-  it('relative path with the same directory', () => {
-    expect(relativePath('src/utils.ts', 'src/index.ts')).toBe('./index.ts')
-  })
-  it('relative from a subdirectory', () => {
-    expect(relativePath('src/something/utils.ts', 'src/index.ts')).toBe(
-      '../index.ts',
-    )
-  })
-  it('relative to a subdirectory', () => {
-    expect(relativePath('src/utils.ts', 'src/something/index.ts')).toBe(
-      './something/index.ts',
-    )
-  })
-  it('same deep directory', () => {
-    expect(
-      relativePath('src/foo/bar/baz/utils.ts', 'src/foo/bar/baz/index.ts'),
-    ).toBe('./index.ts')
-  })
-  it('up several levels and down several levels', () => {
-    expect(relativePath('src/bar/baz/utils.ts', 'src/foo/bar/index.ts')).toBe(
-      '../../foo/bar/index.ts',
-    )
-  })
-  it('relative path with a different directory', () => {
-    expect(
-      relativePath(
-        './src/routes/__root.tsx.ejs',
-        'src/integrations/tanstack-query/layout.tsx',
-      ),
-    ).toBe('../integrations/tanstack-query/layout.tsx')
-  })
-})
-
-describe('readFileHelper', () => {
-  it('should read a file', async () => {
-    vol.mkdirSync('/src')
-    fs.writeFileSync('/src/test.txt', 'Hello')
-    expect(readFileHelper('/src/test.txt')).toBe('Hello')
-  })
-  it('should read a binary file', async () => {
-    vol.mkdirSync('/src')
-    fs.writeFileSync('/src/test.jpg', 'Hello')
-    expect(readFileHelper('/src/test.jpg')).toBe('base64::SGVsbG8=')
-  })
-})
-
-describe('isDirectory', () => {
-  it('should check on files and directories', () => {
-    vol.mkdirSync('/src')
-    fs.writeFileSync('/src/test.txt', 'Hello')
-    expect(isDirectory('/src/test.txt')).toBe(false)
-    expect(isDirectory('/src')).toBe(true)
-  })
-})
-
-describe('findFilesRecursively', () => {
-  it('find files recursively', () => {
-    vol.mkdirSync('/src/subdir/subdir2', { recursive: true })
-    fs.writeFileSync('/src/test.txt', 'Hello')
-    fs.writeFileSync('/src/subdir/test.txt', 'Hello')
-    fs.writeFileSync('/src/subdir/subdir2/test.txt', 'Hello')
-
-    const files = {}
-    findFilesRecursively('/src', files)
-
-    expect(Object.keys(files)).toEqual([
-      '/src/subdir/subdir2/test.txt',
-      '/src/subdir/test.txt',
-      '/src/test.txt',
-    ])
-  })
-})