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

package/tests/add-to-app.test.ts

@@ -0,0 +1,358 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fs, vol } from 'memfs'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import {
+  addToApp,
+  getCurrentConfiguration,
+  hasPendingGitChanges,
+  runNewCommands,
+  writeFiles,
+} from '../src/add-to-app.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)
+
+const fakeCTAJSON: PersistedOptions = {
+  projectName: 'test',
+  targetDir: '/foo',
+  framework: 'test',
+  mode: 'code-router',
+  existingAddOns: [],
+  version: 1,
+  typescript: true,
+  tailwind: true,
+  packageManager: 'npm',
+  git: true,
+}
+
+beforeEach(() => {
+  const fakeFiles = {
+    './package.json': JSON.stringify({
+      name: 'test',
+      version: '1.0.0',
+      dependencies: {},
+    }),
+  }
+
+  vol.reset()
+  __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([]),
+  })
+})
+
+const configFile: PersistedOptions = {
+  projectName: 'test',
+  targetDir: '/foo',
+  framework: 'test',
+  mode: 'code-router',
+  existingAddOns: [],
+  version: 1,
+  typescript: true,
+  tailwind: true,
+  packageManager: 'npm',
+  git: true,
+}
+
+describe('getCurrentConfiguration', () => {
+  it('should check for the config file', async () => {
+    const { environment } = createMemoryEnvironment()
+    const out = await getCurrentConfiguration(environment, '/foo')
+    expect(out).toBeUndefined()
+  })
+
+  it('should read the config file', async () => {
+    const { environment } = createMemoryEnvironment()
+
+    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
+
+    const out = await getCurrentConfiguration(environment, '/foo')
+    expect(out).toEqual(configFile)
+  })
+})
+
+describe('hasPendingGitChanges', () => {
+  it('should check for pending git changes', async () => {
+    const { environment } = createMemoryEnvironment()
+    environment.execute = () => Promise.resolve({ stdout: '' })
+    const out = await hasPendingGitChanges(environment, '/foo')
+    expect(out).toBe(false)
+  })
+
+  it('should check for pending git changes', async () => {
+    const { environment } = createMemoryEnvironment()
+    environment.execute = () => Promise.resolve({ stdout: 'M foo' })
+    const out = await hasPendingGitChanges(environment, '/foo')
+    expect(out).toBe(true)
+  })
+})
+
+describe('writeFiles', () => {
+  it('should prompt for confirmation when not forced', async () => {
+    const { environment } = createMemoryEnvironment('/foo')
+    environment.writeFile('/foo/bloop.txt', 'bloop')
+    environment.writeFile(
+      '/foo/package.json',
+      JSON.stringify(
+        {
+          name: 'test',
+          version: '1.0.0',
+          dependencies: {},
+        },
+        null,
+        2,
+      ),
+    )
+    environment.writeFile('/foo/bar.txt', 'bar')
+    environment.confirm = () => Promise.resolve(false)
+    let thrown = false
+    writeFiles(
+      environment,
+      '/foo',
+      {
+        files: {
+          './bar.txt': 'baz',
+          './blarg.txt': 'blarg',
+        },
+        deletedFiles: [],
+      },
+      false,
+    )
+      .catch((e) => {
+        thrown = true
+      })
+      .finally(() => {
+        expect(thrown).toBe(true)
+      })
+  })
+
+  it('should not prompt for confirmation when forced', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
+    environment.writeFile('/foo/blooop.txt', 'blooop')
+    await writeFiles(
+      environment,
+      '/foo',
+      {
+        files: {
+          './bar.txt': 'baz',
+          './blarg.txt': 'blarg',
+        },
+        deletedFiles: [],
+      },
+      true,
+    )
+    environment.finishRun()
+    expect(output.files).toEqual({
+      './blooop.txt': 'blooop',
+      './bar.txt': 'baz',
+      './blarg.txt': 'blarg',
+    })
+  })
+
+  it('should handle binary files', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
+    environment.writeFile('/foo/unchanged.jpg', 'base64::foobaz')
+    environment.writeFile('/foo/changing.jpg', 'base64::foobaz')
+    await writeFiles(
+      environment,
+      '/foo',
+      {
+        files: {
+          './unchanged.jpg': 'base64::foobaz',
+          './changing.jpg': 'base64::aGVsbG8=',
+          './new.jpg': 'base64::aGVsbG8=',
+        },
+        deletedFiles: [],
+      },
+      true,
+    )
+    environment.finishRun()
+    // It's ok for unchanged.jpg not to be written, because it matches the existing file
+    expect(output.files).toEqual({
+      './unchanged.jpg': 'base64::foobaz',
+      './changing.jpg': 'base64::aGVsbG8=',
+      './new.jpg': 'base64::aGVsbG8=',
+    })
+  })
+
+  it('should handle package.json', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    environment.writeFile(
+      '/foo/package.json',
+      JSON.stringify(
+        {
+          name: 'test',
+          version: '1.0.0',
+          scripts: {
+            dev: 'echo "test"',
+          },
+          dependencies: {
+            'test-package-2': '1.0.0',
+          },
+        },
+        null,
+        2,
+      ),
+    )
+    await writeFiles(
+      environment,
+      '/foo',
+      {
+        files: {
+          './package.json': JSON.stringify(
+            {
+              scripts: {
+                test: 'echo "test"',
+              },
+              dependencies: {
+                'test-package': '1.0.0',
+              },
+            },
+            null,
+            2,
+          ),
+        },
+        deletedFiles: [],
+      },
+      true,
+    )
+    environment.finishRun()
+    expect(output.files).toEqual({
+      './package.json': JSON.stringify(
+        {
+          name: 'test',
+          version: '1.0.0',
+          scripts: {
+            dev: 'echo "test"',
+            test: 'echo "test"',
+          },
+          dependencies: {
+            'test-package-2': '1.0.0',
+            'test-package': '1.0.0',
+          },
+          devDependencies: {},
+        },
+        null,
+        2,
+      ),
+    })
+  })
+
+  it('should delete files', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    environment.writeFile('/foo/bloop.txt', 'bloop')
+    await writeFiles(
+      environment,
+      '/foo',
+      { files: {}, deletedFiles: ['./bloop.txt'] },
+      true,
+    )
+    environment.finishRun()
+    expect(output.deletedFiles).toEqual(['./bloop.txt'])
+  })
+})
+
+describe('runNewCommands', () => {
+  it('should run new commands', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    await runNewCommands(environment, fakeCTAJSON, '/foo', {
+      commands: [{ command: 'echo', args: ['bloop'] }],
+    })
+    environment.finishRun()
+    expect(output.commands).toEqual([{ command: 'echo', args: ['bloop'] }])
+  })
+})
+
+describe('addToApp', () => {
+  it('should add an add-on', async () => {
+    const { environment, output } = createMemoryEnvironment('/foo')
+    environment.startRun()
+    environment.writeFile(
+      '/foo/.cta.json',
+      JSON.stringify(fakeCTAJSON, null, 2),
+    )
+    environment.writeFile(
+      '/foo/package.json',
+      JSON.stringify(
+        {
+          name: 'test',
+          version: '1.0.0',
+          scripts: {},
+          dependencies: {},
+          devDependencies: {},
+        },
+        null,
+        2,
+      ),
+    )
+    await addToApp(environment, ['test'], '/foo', {
+      forced: true,
+    })
+    environment.finishRun()
+    expect(output.files).toEqual({
+      './jack.txt': 'foo',
+      './package.json': JSON.stringify(
+        {
+          name: 'test',
+          version: '1.0.0',
+          scripts: {},
+          dependencies: {
+            'test-package': '1.0.0',
+          },
+          devDependencies: {},
+        },
+        null,
+        2,
+      ),
+    })
+  })
+})

package/tests/config-file.test.ts

@@ -2,9 +2,12 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { fs, vol } from 'memfs'
 import { resolve } from 'node:path'
 
-import { readConfigFile, writeConfigFile } from '../src/config-file.js'
+import {
+  readConfigFileFromEnvironment,
+  writeConfigFileToEnvironment,
+} from '../src/config-file.js'
 import { CONFIG_FILE } from '../src/constants.js'
-
+import { createMemoryEnvironment } from '../src/environment.js'
 import type { AddOn, Environment, Framework, Options } from '../src/types.js'
 
 vi.mock('node:fs', () => fs)
@@ -16,6 +19,7 @@ beforeEach(() => {
 
 describe('writeConfigFile', () => {
   it('should write the config file', async () => {
+    const targetDir = 'test-dir'
     const options = {
       framework: {
         id: 'react-cra',
@@ -25,12 +29,11 @@ describe('writeConfigFile', () => {
         {
           id: 'add-on-1',
           description: 'Add-on 1',
-          templates: ['file-router'],
+          modes: ['file-router'],
         } as AddOn,
       ],
-      addOns: [],
+      targetDir,
     } as unknown as Options
-    const targetDir = 'test-dir'
     const persistedOptions = {
       version: 1,
       framework: options.framework.id,
@@ -42,23 +45,24 @@ describe('writeConfigFile', () => {
         expect(optionsString).toEqual(JSON.stringify(persistedOptions, null, 2))
       },
     } as Environment
-    await writeConfigFile(env, targetDir, options)
+    await writeConfigFileToEnvironment(env, options)
   })
 })
 
-describe('readConfigFile', () => {
+describe('readConfigFileFromEnvironment', () => {
   it('should read the config file', async () => {
+    const targetDir = 'test-dir'
     const persistedOptions = {
       version: 1,
       framework: 'react-cra',
       existingAddOns: ['add-on-1'],
     }
-    vol.mkdirSync('/test')
-    vol.writeFileSync(
-      resolve('/test', CONFIG_FILE),
+    const { environment } = createMemoryEnvironment()
+    environment.writeFile(
+      resolve(targetDir, CONFIG_FILE),
       JSON.stringify(persistedOptions, null, 2),
     )
-    const config = await readConfigFile('/test')
+    const config = await readConfigFileFromEnvironment(environment, targetDir)
     expect(config).toEqual(persistedOptions)
   })
 })

package/tests/create-app.test.ts

@@ -1,6 +1,5 @@
-import { resolve } from 'node:path'
-
 import { describe, expect, it } from 'vitest'
+import { resolve } from 'node:path'
 
 import { createApp } from '../src/create-app.js'
 
@@ -10,6 +9,7 @@ import { AddOn, Options } from '../src/types.js'
 
 const simpleOptions = {
   projectName: 'test',
+  targetDir: '/',
   framework: {
     id: 'test',
     name: 'Test',
@@ -37,6 +37,7 @@ const simpleOptions = {
     },
     getFiles: () => ['./src/test.txt'],
     getFileContents: () => 'Hello',
+    getDeletedFiles: () => [],
   },
   chosenAddOns: [],
   packageManager: 'pnpm',
@@ -49,25 +50,16 @@ const simpleOptions = {
 describe('createApp', () => {
   it('should create an app', async () => {
     const { environment, output } = createMemoryEnvironment()
-    await createApp(simpleOptions, {
-      silent: true,
-      environment,
-      name: 'Test',
-      cwd: '/',
-      appName: 'TanStack App',
-    })
+    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(simpleOptions, {
-      silent: false,
-      environment,
-      name: 'Test',
-      cwd: '/foo/bar/baz',
-      appName: 'TanStack App',
+    await createApp(environment, {
+      ...simpleOptions,
+      targetDir: '/foo/bar/baz',
     })
 
     const cwd = process.cwd()
@@ -79,26 +71,18 @@ describe('createApp', () => {
 
   it('should create an app - with a starter', async () => {
     const { environment, output } = createMemoryEnvironment()
-    await createApp(
-      {
-        ...simpleOptions,
-        starter: {
-          command: {
-            command: 'echo',
-            args: ['Hello'],
-          },
-          getFiles: () => ['./src/test2.txt'],
-          getFileContents: () => 'Hello-2',
-        } as unknown as AddOn,
-      },
-      {
-        silent: false,
-        environment,
-        name: 'Test',
-        cwd: '/',
-        appName: 'TanStack App',
-      },
-    )
+    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)
@@ -106,39 +90,31 @@ describe('createApp', () => {
 
   it('should create an app - with a add-on', async () => {
     const { environment, output } = createMemoryEnvironment()
-    await createApp(
-      {
-        ...simpleOptions,
-        git: true,
-        addOns: 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=',
-          } as unknown as AddOn,
-        ],
-      },
-      {
-        silent: false,
-        environment,
-        name: 'Test',
-        cwd: '/',
-        appName: 'TanStack App',
-      },
-    )
+    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,
+      ],
+    })
 
-    expect(output.files['/src/test2.txt']).toEqual('hello')
+    // 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

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