@tanstack/cta-engine 0.14.3 → 0.14.4

package/tests/integrations/shadcn.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../../src/environment.js'
+import { installShadcnComponents } from '../../src/integrations/shadcn.js'
+
+import type { Options } from '../../src/types.js'
+
+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)
+    environment.finishRun()
+
+    expect(output.commands).toEqual([])
+  })
+
+  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)
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'pnpx',
+        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
+      },
+    ])
+  })
+
+  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'],
+      },
+      spinner: () => ({
+        start: () => {},
+        succeed: () => {},
+        fail: () => {},
+      }),
+    } as unknown as Options)
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'pnpx',
+        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
+      },
+    ])
+  })
+})

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/package-json.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+
+import { createPackageJSON } from '../src/package-json.js'
+import { FILE_ROUTER } from '../src/constants.js'
+
+import type { Options, Framework } from '../src/types.js'
+
+describe('createPackageJSON', () => {
+  it('should create a package.json', () => {
+    const packageJSON = createPackageJSON({
+      chosenAddOns: [
+        {
+          packageAdditions: {
+            scripts: {
+              dev: 'file-router dev',
+            },
+          },
+        },
+      ],
+      mode: FILE_ROUTER,
+      typescript: true,
+      tailwind: true,
+      projectName: 'test',
+      framework: {
+        basePackageJSON: {},
+        optionalPackages: {
+          typescript: {
+            devDependencies: {
+              typescript: '^5.0.0',
+            },
+          },
+          tailwindcss: {
+            dependencies: {
+              tailwindcss: '^3.0.0',
+            },
+          },
+          'file-router': {
+            dependencies: {
+              'file-router': '^1.0.0',
+            },
+          },
+        },
+      } as unknown as Framework,
+    } as unknown as Options)
+
+    const expected = {
+      name: 'test',
+      dependencies: {
+        'file-router': '^1.0.0',
+        tailwindcss: '^3.0.0',
+      },
+      devDependencies: {
+        typescript: '^5.0.0',
+      },
+      scripts: {
+        dev: 'file-router dev',
+      },
+    }
+
+    // Use JSON.stringify to test sorting order of dependencies
+    expect(JSON.stringify(packageJSON)).toEqual(JSON.stringify(expected))
+  })
+})

package/tests/package-manager.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  getPackageManagerExecuteCommand,
+  getPackageManagerInstallCommand,
+  getPackageManagerScriptCommand,
+} from '../src/package-manager.js'
+import { formatCommand } from '../src/utils.js'
+
+describe('getPackageManagerScriptCommand', () => {
+  it('yarn', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('yarn', ['dev']))).toBe(
+      'yarn run dev',
+    )
+  })
+  it('pnpm', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('pnpm', ['dev']))).toBe(
+      'pnpm dev',
+    )
+  })
+  it('bun', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('bun', ['dev']))).toBe(
+      'bunx --bun run dev',
+    )
+  })
+  it('deno', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('deno', ['dev']))).toBe(
+      'deno task dev',
+    )
+  })
+  it('npm', () => {
+    expect(formatCommand(getPackageManagerScriptCommand('npm', ['dev']))).toBe(
+      'npm run dev',
+    )
+  })
+})
+
+describe('getPackageManagerExecuteCommand', () => {
+  it('yarn', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('yarn', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('yarn dlx shadcn add button')
+  })
+  it('pnpm', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('pnpm', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('pnpx shadcn add button')
+  })
+  it('bun', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('bun', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('bunx --bun shadcn add button')
+  })
+  it('deno', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('deno', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('deno run npm:shadcn add button')
+  })
+  it('npm', () => {
+    expect(
+      formatCommand(
+        getPackageManagerExecuteCommand('npm', 'shadcn', ['add', 'button']),
+      ),
+    ).toBe('npx shadcn add button')
+  })
+})
+
+describe('getPackageManagerInstallCommand', () => {
+  it('yarn install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('yarn'))).toBe(
+      'yarn install',
+    )
+  })
+  it('pnpm install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('pnpm'))).toBe(
+      'pnpm install',
+    )
+  })
+  it('bun install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('bun'))).toBe(
+      'bun install',
+    )
+  })
+  it('deno install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('deno'))).toBe(
+      'deno install',
+    )
+  })
+  it('npm install', () => {
+    expect(formatCommand(getPackageManagerInstallCommand('npm'))).toBe(
+      'npm install',
+    )
+  })
+
+  it('yarn install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('yarn', 'radix-ui')),
+    ).toBe('yarn add radix-ui')
+  })
+  it('pnpm install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('pnpm', 'radix-ui')),
+    ).toBe('pnpm add radix-ui')
+  })
+  it('bun install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('bun', 'radix-ui')),
+    ).toBe('bun install radix-ui')
+  })
+  it('deno install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('deno', 'radix-ui')),
+    ).toBe('deno install radix-ui')
+  })
+  it('npm install radix-ui', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('npm', 'radix-ui')),
+    ).toBe('npm install radix-ui')
+  })
+
+  it('yarn install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('yarn', 'vitest', true)),
+    ).toBe('yarn add vitest --dev')
+  })
+  it('pnpm install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('pnpm', 'vitest', true)),
+    ).toBe('pnpm add vitest --dev')
+  })
+  it('bun install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('bun', 'vitest', true)),
+    ).toBe('bun install vitest -D')
+  })
+  it('deno install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('deno', 'vitest', true)),
+    ).toBe('deno install vitest -D')
+  })
+  it('npm install vitest in dev mode', () => {
+    expect(
+      formatCommand(getPackageManagerInstallCommand('npm', 'vitest', true)),
+    ).toBe('npm install vitest -D')
+  })
+})

package/tests/setupVitest.ts

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

package/tests/template-file.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { createTemplateFile } from '../src/template-file.js'
+import { FILE_ROUTER } from '../src/constants.js'
+
+import type { AddOn, Integration, Options } from '../src/types.js'
+
+const simpleOptions = {
+  projectName: 'test',
+  targetDir: '/test',
+  framework: {
+    id: 'test',
+    name: 'Test',
+  },
+  chosenAddOns: [],
+  packageManager: 'pnpm',
+  typescript: true,
+  tailwind: true,
+  mode: FILE_ROUTER,
+} as unknown as Options
+
+describe('createTemplateFile', () => {
+  it('should template a simple file', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile('./test.ts', 'let a = 1')
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts'].trim()).toEqual('let a = 1')
+  })
+
+  it('should handle ignore files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+    } as unknown as Options)
+    environment.startRun()
+    await templateFile('./test.ts.ejs', '<% ignoreFile() %>let a = 1')
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts']).toBeUndefined()
+  })
+
+  it('should handle append files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile('./test.txt.ejs', 'Line 1\n')
+    await templateFile('./test.txt.append', 'Line 2\n')
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Line 1\nLine 2\n')
+  })
+
+  it('should handle enabled add-ons', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      chosenAddOns: [
+        {
+          id: 'test1',
+          name: 'Test 1',
+        },
+        {
+          id: 'test2',
+          name: 'Test 2',
+        },
+      ] as Array<AddOn>,
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "Addons: <%= Object.keys(addOnEnabled).join(', ') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Addons: test1, test2')
+  })
+
+  it('should handle relative paths', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      './src/test/test.txt.ejs',
+      "import { foo } from '<%= relativePath('./foo.ts') %>'",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/src/test/test.txt']).toEqual(
+      "import { foo } from '../../foo.ts'",
+    )
+  })
+
+  it('should handle routes', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      chosenAddOns: [
+        {
+          id: 'test',
+          name: 'Test',
+          routes: [
+            {
+              path: '/test',
+              name: 'Test',
+              url: '/test',
+              jsName: 'test',
+            },
+          ],
+        } as AddOn,
+      ],
+    })
+
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "<%= routes.map((route) => route.url).join(', ') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('/test')
+  })
+
+  it('should handle integrations', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      chosenAddOns: [
+        {
+          id: 'test',
+          name: 'Test',
+          integrations: [
+            {
+              type: 'header-user',
+              path: '/test',
+              jsName: 'test',
+            } as Integration,
+          ],
+        } as AddOn,
+      ],
+    })
+
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      "<%= integrations.map((integration) => integration.path).join(', ') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('/test')
+  })
+
+  it('should handle package manager', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      './foo.txt.ejs',
+      "<%= getPackageManagerAddScript('foo') %>",
+    )
+    await templateFile(
+      './foo-dev.txt.ejs',
+      "<%= getPackageManagerAddScript('foo', true) %>",
+    )
+    await templateFile(
+      './run-dev.txt.ejs',
+      "<%= getPackageManagerRunScript('dev') %>",
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/foo.txt']).toEqual('pnpm add foo')
+    expect(output.files['/test/foo-dev.txt']).toEqual('pnpm add foo --dev')
+    expect(output.files['/test/run-dev.txt']).toEqual('pnpm dev')
+  })
+})

package/tests/utils.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { formatCommand, jsSafeName, sortObject } from '../src/utils.js'
+
+describe('formatCommand', () => {
+  it('should format a command', () => {
+    expect(formatCommand({ command: 'echo', args: ['test'] })).toEqual(
+      'echo test',
+    )
+  })
+})
+
+describe('jsSafeName', () => {
+  it('should convert a string to a safe JS name', () => {
+    expect(jsSafeName('test.foo')).toEqual('TestFoo')
+  })
+})
+
+describe('sortObject', () => {
+  it('should sort an object', () => {
+    expect(sortObject({ b: 'b', a: 'a' })).toEqual({ a: 'a', b: 'b' })
+  })
+})

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config'
+import path from 'node:path'
+
+export default defineConfig({
+  test: {
+    setupFiles: ['./tests/setupVitest.js'],
+    deps: {
+      moduleDirectories: ['node_modules', path.resolve('../../packages')],
+    },
+    coverage: {
+      exclude: [
+        'node_modules',
+        'dist',
+        'build',
+        'tests/**',
+        '**/types.ts',
+        'vitest.config.ts',
+      ],
+    },
+  },
+})