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

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

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

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

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

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

package/tests/frameworks.test.ts

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

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

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