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

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

@@ -31,6 +31,25 @@ describe('createMemoryEnvironment', () => {
     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()
 

package/tests/integrations/shadcn.test.ts

@@ -9,22 +9,17 @@ 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,
-    )
+    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([])
@@ -33,31 +28,26 @@ describe('shadcn', () => {
   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,
-    )
+    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([
@@ -71,29 +61,24 @@ describe('shadcn', () => {
   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'],
+    await installShadcnComponents(environment, '/test', {
+      packageManager: 'pnpm',
+      chosenAddOns: [
+        {
+          id: 'shadcn',
         },
-        spinner: () => ({
-          start: () => {},
-          succeed: () => {},
-          fail: () => {},
-        }),
-      } as unknown as Options,
-      false,
-    )
+      ],
+      projectName: 'test',
+      typescript: true,
+      starter: {
+        shadcnComponents: ['button', 'card'],
+      },
+      spinner: () => ({
+        start: () => {},
+        succeed: () => {},
+        fail: () => {},
+      }),
+    } as unknown as Options)
     environment.finishRun()
 
     expect(output.commands).toEqual([

package/tests/options.test.ts

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

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