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

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

package/tests/integrations/shadcn.test.ts

@@ -0,0 +1,106 @@
+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,
+      true,
+    )
+    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,
+      false,
+    )
+    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,
+      false,
+    )
+    environment.finishRun()
+
+    expect(output.commands).toEqual([
+      {
+        command: 'pnpx',
+        args: ['shadcn@latest', 'add', '--silent', '--yes', 'button', 'card'],
+      },
+    ])
+  })
+})

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/template-file.test.ts

@@ -0,0 +1,215 @@
+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',
+  framework: {
+    id: 'test',
+    name: 'Test',
+  },
+  chosenAddOns: [],
+  packageManager: 'pnpm',
+  typescript: true,
+  tailwind: true,
+  mode: FILE_ROUTER,
+  variableValues: {
+    a: 'foo',
+  },
+} as unknown as Options
+
+describe('createTemplateFile', () => {
+  it('should template a simple file', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions, '/test')
+    environment.startRun()
+    await templateFile('./test.ts', 'let a = 1')
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts'].trim()).toEqual('let a = 1')
+  })
+
+  it('should template a simple file with ejs', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+        variableValues: {
+          a: 'foo',
+        },
+      } as unknown as Options,
+      '/test',
+    )
+    environment.startRun()
+    await templateFile('./test.ts.ejs', "let a = '<%= variables.a %>'")
+    environment.finishRun()
+
+    expect(output.files['/test/test.ts'].trim()).toEqual("let a = 'foo'")
+  })
+
+  it('should handle ignore files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(
+      environment,
+      {
+        ...simpleOptions,
+      } as unknown as Options,
+      '/test',
+    )
+    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, '/test')
+    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>,
+      },
+      '/test',
+    )
+    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, '/test')
+    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,
+        ],
+      },
+      '/test',
+    )
+
+    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,
+        ],
+      },
+      '/test',
+    )
+
+    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, '/test')
+    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' })
+  })
+})