@tanstack/cta-engine 0.14.3 → 0.14.4

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',
+  chosenAddOns: [],
+  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',
+  chosenAddOns: [],
+  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

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fs, vol } from 'memfs'
+import { resolve } from 'node:path'
+
+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)
+vi.mock('node:fs/promises', () => fs.promises)
+
+beforeEach(() => {
+  vol.reset()
+})
+
+describe('writeConfigFile', () => {
+  it('should write the config file', async () => {
+    const targetDir = 'test-dir'
+    const options = {
+      framework: {
+        id: 'react-cra',
+        getAddOns: () => [],
+      } as unknown as Framework,
+      chosenAddOns: [
+        {
+          id: 'add-on-1',
+          description: 'Add-on 1',
+          modes: ['file-router'],
+        } as AddOn,
+      ],
+      targetDir,
+    } as unknown as Options
+    const persistedOptions = {
+      version: 1,
+      framework: options.framework.id,
+      chosenAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+    }
+    const env = {
+      writeFile: (path, optionsString) => {
+        expect(path).toEqual(resolve(targetDir, CONFIG_FILE))
+        expect(optionsString).toEqual(JSON.stringify(persistedOptions, null, 2))
+      },
+    } as Environment
+    await writeConfigFileToEnvironment(env, options)
+  })
+})
+
+describe('readConfigFileFromEnvironment', () => {
+  it('should read the config file', async () => {
+    const targetDir = 'test-dir'
+    const persistedOptions = {
+      version: 1,
+      framework: 'react-cra',
+      chosenAddOns: ['add-on-1'],
+    }
+    const { environment } = createMemoryEnvironment()
+    environment.writeFile(
+      resolve(targetDir, CONFIG_FILE),
+      JSON.stringify(persistedOptions, null, 2),
+    )
+    const config = await readConfigFileFromEnvironment(environment, targetDir)
+    expect(config).toEqual(persistedOptions)
+  })
+
+  it('should upgrade old config files', async () => {
+    const targetDir = 'test-dir'
+    const persistedOptions = {
+      framework: 'react',
+      projectName: 'foo',
+      typescript: false,
+      tailwind: false,
+      packageManager: 'pnpm',
+      toolchain: 'none',
+      mode: 'code-router',
+      git: true,
+      variableValues: {},
+      version: 1,
+      existingAddOns: [],
+    }
+    const { output, environment } = createMemoryEnvironment()
+    environment.writeFile(
+      resolve(targetDir, CONFIG_FILE),
+      JSON.stringify(persistedOptions, null, 2),
+    )
+    const config = await readConfigFileFromEnvironment(environment, targetDir)
+
+    environment.finishRun()
+
+    expect(config).toEqual({
+      framework: 'react-cra',
+      projectName: 'foo',
+      typescript: false,
+      tailwind: false,
+      packageManager: 'pnpm',
+      chosenAddOns: [],
+      git: true,
+      mode: 'code-router',
+      version: 1,
+    })
+  })
+})

package/tests/create-app.test.ts

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

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