@tanstack/create 0.49.1

package/tests/filename-processing.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { createTemplateFile } from '../src/template-file.js'
+
+import type { 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',
+  addOnOptions: {},
+} as unknown as Options
+
+describe('Filename Processing - Prefix Stripping', () => {
+  it('should strip single prefix from filename', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'postgres' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__postgres__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL config\nexport default { driver: "postgres" }'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/testAddon.config.ts']).toBeDefined()
+    expect(output.files['/test/testAddon.config.ts'].trim()).toEqual('// PostgreSQL config\nexport default { driver: \'postgres\' }')
+    
+    // Original prefixed filename should not exist
+    expect(output.files['/test/__postgres__testAddon.config.ts']).toBeUndefined()
+  })
+
+  it('should strip prefix from nested directory paths', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'mysql' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      'src/db/__mysql__connection.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL connection\nexport const connection = "mysql"'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped, preserving directory structure
+    expect(output.files['/test/src/db/connection.ts']).toBeDefined()
+    expect(output.files['/test/src/db/connection.ts'].trim()).toEqual('// MySQL connection\nexport const connection = \'mysql\'')
+    
+    // Original prefixed path should not exist
+    expect(output.files['/test/src/db/__mysql__connection.ts']).toBeUndefined()
+  })
+
+  it('should handle multiple prefixed files in same directory', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'sqlite' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__postgres__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL config'
+    )
+    await templateFile(
+      '__mysql__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL config'
+    )
+    await templateFile(
+      '__sqlite__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "sqlite") { ignoreFile() } %>\n// SQLite config'
+    )
+    environment.finishRun()
+
+    // Only SQLite file should exist (others ignored via ignoreFile())
+    expect(output.files['/test/testAddon.config.ts']).toBeDefined()
+    expect(output.files['/test/testAddon.config.ts'].trim()).toEqual('// SQLite config')
+    
+    // Prefixed filenames should not exist
+    expect(output.files['/test/__postgres__testAddon.config.ts']).toBeUndefined()
+    expect(output.files['/test/__mysql__testAddon.config.ts']).toBeUndefined()
+    expect(output.files['/test/__sqlite__testAddon.config.ts']).toBeUndefined()
+  })
+
+  it('should handle complex filename patterns', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        auth: { provider: 'auth0' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__auth0__auth.config.js.ejs',
+      '<% if (addOnOption.auth.provider !== "auth0") { ignoreFile() } %>\n// Auth0 configuration\nmodule.exports = { provider: "auth0" }'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/auth.config.js']).toBeDefined()
+    expect(output.files['/test/auth.config.js'].trim()).toEqual('// Auth0 configuration\nmodule.exports = { provider: "auth0" }')
+  })
+
+  it('should handle prefixed files with .append.ejs extension', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: { database: 'postgres' }
+      }
+    })
+    environment.startRun()
+    // Create base file first
+    await templateFile(
+      '.env.ejs',
+      'BASE_VAR=value\n'
+    )
+    // Then append with prefixed filename
+    await templateFile(
+      '__postgres__.env.append.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\nDATABASE_URL=postgresql://localhost:5432/mydb\n'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped and content appended
+    expect(output.files['/test/.env']).toBeDefined()
+    expect(output.files['/test/.env']).toEqual('BASE_VAR=value\n\nDATABASE_URL=postgresql://localhost:5432/mydb\n')
+  })
+
+  it('should handle files without prefixes normally', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      'regular-file.ts.ejs',
+      'export const config = "normal"'
+    )
+    environment.finishRun()
+
+    // File should be created with normal filename processing
+    expect(output.files['/test/regular-file.ts']).toBeDefined()
+    expect(output.files['/test/regular-file.ts']).toEqual('export const config = \'normal\'\n')
+  })
+
+  it('should handle malformed prefixes gracefully', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, simpleOptions)
+    environment.startRun()
+    await templateFile(
+      '__malformed_prefix.ts.ejs',
+      'export const config = "malformed"'
+    )
+    await templateFile(
+      '__only_one_underscore.ts.ejs',
+      'export const config = "malformed2"'
+    )
+    await templateFile(
+      '____.ts.ejs',
+      'export const config = "empty"'
+    )
+    environment.finishRun()
+
+    // Files with malformed prefixes should be created as-is (minus .ejs extension)
+    expect(output.files['/test/__malformed_prefix.ts']).toBeDefined()
+    expect(output.files['/test/__only_one_underscore.ts']).toBeDefined()
+    expect(output.files['/test/____.ts']).toBeDefined()
+  })
+
+  it('should handle deeply nested prefixed files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        styling: { framework: 'tailwind' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      'src/styles/components/__tailwind__button.css.ejs',
+      '<% if (addOnOption.styling.framework !== "tailwind") { ignoreFile() } %>\n@tailwind base;\n@tailwind components;\n@tailwind utilities;'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped, preserving deep directory structure
+    expect(output.files['/test/src/styles/components/button.css']).toBeDefined()
+    expect(output.files['/test/src/styles/components/button.css'].trim()).toEqual('@tailwind base;\n@tailwind components;\n@tailwind utilities;')
+  })
+
+  it('should handle prefix stripping with different option values', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        ui: { library: 'chakra' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__chakra__theme.ts.ejs',
+      '<% if (addOnOption.ui.library !== "chakra") { ignoreFile() } %>\n// Chakra UI theme\nexport const theme = { colors: {} }'
+    )
+    await templateFile(
+      '__mui__theme.ts.ejs',
+      '<% if (addOnOption.ui.library !== "mui") { ignoreFile() } %>\n// Material-UI theme\nexport const theme = { palette: {} }'
+    )
+    environment.finishRun()
+
+    // Only Chakra file should exist (MUI ignored via ignoreFile())
+    expect(output.files['/test/theme.ts']).toBeDefined()
+    expect(output.files['/test/theme.ts'].trim()).toEqual('// Chakra UI theme\nexport const theme = { colors: {} }')
+    
+    // Prefixed filenames should not exist
+    expect(output.files['/test/__chakra__theme.ts']).toBeUndefined()
+    expect(output.files['/test/__mui__theme.ts']).toBeUndefined()
+  })
+
+  it('should handle complex prefix with special characters', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        deployment: { platform: 'vercel-edge' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__vercel-edge__api.ts.ejs',
+      '<% if (addOnOption.deployment.platform !== "vercel-edge") { ignoreFile() } %>\n// Vercel Edge API\nexport const runtime = "edge"'
+    )
+    environment.finishRun()
+
+    // File should be created with prefix stripped
+    expect(output.files['/test/api.ts']).toBeDefined()
+    expect(output.files['/test/api.ts'].trim()).toEqual('// Vercel Edge API\nexport const runtime = \'edge\'')
+  })
+
+  it('should handle multiple prefixes in same filename (edge case)', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        test: { value: 'postgres' }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      '__postgres__file__with__underscores.ts.ejs',
+      '<% if (addOnOption.test.value !== "postgres") { ignoreFile() } %>\n// File with underscores\nexport const value = "test"'
+    )
+    environment.finishRun()
+
+    // Should only strip the first valid prefix pattern
+    expect(output.files['/test/file__with__underscores.ts']).toBeDefined()
+    expect(output.files['/test/file__with__underscores.ts'].trim()).toEqual('// File with underscores\nexport const value = \'test\'')
+  })
+})

package/tests/frameworks.test.ts

@@ -0,0 +1,63 @@
+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',
+    }
+
+    registerFramework({
+      id: 'test',
+      name: 'Test',
+      addOns: [],
+      description: 'Test',
+      version: '1.0.0',
+      base: {
+        'package.json': JSON.stringify(basePackageJSON),
+      },
+      basePackageJSON,
+      optionalPackages: {},
+      supportedModes: {
+        'code-router': {
+          displayName: 'Code Router',
+          description: 'Code Router',
+          forceTypescript: false,
+        },
+      },
+    })
+
+    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))
+
+    expect(getFrameworkByName('Test')).not.toBeUndefined()
+    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,107 @@
+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: 'pnpm',
+        args: [
+          'dlx',
+          '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: 'pnpm',
+        args: [
+          'dlx',
+          '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,62 @@
+import { describe, expect, it } from 'vitest'
+
+import { createPackageJSON } from '../src/package-json.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',
+      devDependencies: {
+        typescript: '^5.0.0',
+      },
+      dependencies: {
+        'file-router': '^1.0.0',
+        tailwindcss: '^3.0.0',
+      },
+      scripts: {
+        dev: 'file-router dev',
+      },
+    }
+
+    // Use JSON.stringify to test sorting order of dependencies
+    expect(JSON.stringify(packageJSON)).toEqual(JSON.stringify(expected))
+  })
+})