@tanstack/cta-engine 0.28.0 → 0.29.1

package/tests/package-json.test.ts

@@ -44,13 +44,13 @@ describe('createPackageJSON', () => {
 
     const expected = {
       name: 'test',
+      devDependencies: {
+        typescript: '^5.0.0',
+      },
       dependencies: {
         'file-router': '^1.0.0',
         tailwindcss: '^3.0.0',
       },
-      devDependencies: {
-        typescript: '^5.0.0',
-      },
       scripts: {
         dev: 'file-router dev',
       },

package/tests/special-steps.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import * as fs from 'node:fs'
+import { postInitScript } from '../src/special-steps/post-init-script.js'
+import { rimrafNodeModules } from '../src/special-steps/rimraf-node-modules.js'
+import { runSpecialSteps } from '../src/special-steps/index.js'
+
+import type { Environment, Options } from '../src/types.js'
+
+vi.mock('node:fs')
+
+describe('Special Steps', () => {
+  let mockEnvironment: Environment
+  let mockOptions: Options
+
+  beforeEach(() => {
+    mockEnvironment = {
+      exists: vi.fn(),
+      execute: vi.fn(),
+      startStep: vi.fn(),
+      finishStep: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      info: vi.fn(),
+      rimraf: vi.fn(),
+      deleteFile: vi.fn(),
+      readFile: vi.fn(),
+    } as unknown as Environment
+
+    mockOptions = {
+      targetDir: '/test/project',
+      packageManager: 'npm',
+      chosenAddOns: [],
+    } as Options
+  })
+
+  describe('postInitScript', () => {
+    it('should run post-cta-init script when it exists', async () => {
+      const mockPackageJson = {
+        scripts: {
+          'post-cta-init': 'echo "Running post-cta-init"',
+        },
+      }
+
+      vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify(mockPackageJson),
+      )
+
+      await postInitScript(mockEnvironment, mockOptions)
+
+      expect(mockEnvironment.startStep).toHaveBeenCalledWith({
+        id: 'post-init-script',
+        type: 'command',
+        message: 'Running post-cta-init script...',
+      })
+
+      expect(mockEnvironment.execute).toHaveBeenCalledWith(
+        'npm',
+        ['run', 'post-cta-init'],
+        '/test/project',
+        { inherit: true },
+      )
+
+      expect(mockEnvironment.finishStep).toHaveBeenCalledWith(
+        'post-init-script',
+        'Post-cta-init script complete',
+      )
+    })
+
+    it('should skip when package.json does not exist', async () => {
+      vi.spyOn(mockEnvironment, 'exists').mockReturnValue(false)
+
+      await postInitScript(mockEnvironment, mockOptions)
+
+      expect(mockEnvironment.warn).toHaveBeenCalledWith(
+        'Warning',
+        'No package.json found, skipping post-cta-init script',
+      )
+      expect(mockEnvironment.execute).not.toHaveBeenCalled()
+    })
+
+    it('should skip when post-cta-init script does not exist', async () => {
+      const mockPackageJson = {
+        scripts: {
+          build: 'echo "Building"',
+        },
+      }
+
+      vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify(mockPackageJson),
+      )
+
+      await postInitScript(mockEnvironment, mockOptions)
+
+      // Note: The function now skips silently without calling info()
+      expect(mockEnvironment.execute).not.toHaveBeenCalled()
+    })
+
+    it('should handle different package managers', async () => {
+      const packageManagers = ['yarn', 'pnpm', 'bun', 'deno'] as const
+      const expectedCommands = {
+        yarn: { command: 'yarn', args: ['run', 'post-cta-init'] },
+        pnpm: { command: 'pnpm', args: ['post-cta-init'] },
+        bun: { command: 'bun', args: ['--bun', 'run', 'post-cta-init'] },
+        deno: { command: 'deno', args: ['task', 'post-cta-init'] },
+      }
+
+      for (const pm of packageManagers) {
+        mockOptions.packageManager = pm
+        vi.clearAllMocks()
+        vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
+        vi.mocked(fs.readFileSync).mockReturnValue(
+          JSON.stringify({ scripts: { 'post-cta-init': 'test' } }),
+        )
+
+        await postInitScript(mockEnvironment, mockOptions)
+
+        const expected = expectedCommands[pm]
+        expect(mockEnvironment.execute).toHaveBeenCalledWith(
+          expected.command,
+          expected.args,
+          '/test/project',
+          { inherit: true },
+        )
+      }
+    })
+  })
+
+  describe('runSpecialSteps', () => {
+    it('should run multiple special steps in sequence', async () => {
+      const specialSteps = ['rimraf-node-modules', 'post-init-script']
+
+      vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ scripts: { 'post-cta-init': 'test' } }),
+      )
+
+      await runSpecialSteps(mockEnvironment, mockOptions, specialSteps)
+
+      expect(mockEnvironment.startStep).toHaveBeenCalledWith({
+        id: 'special-steps',
+        type: 'command',
+        message: 'Running special steps...',
+      })
+
+      expect(mockEnvironment.rimraf).toHaveBeenCalled()
+      expect(mockEnvironment.execute).toHaveBeenCalled()
+      expect(mockEnvironment.finishStep).toHaveBeenCalledWith(
+        'special-steps',
+        'Special steps complete',
+      )
+    })
+
+    it('should handle unknown special steps', async () => {
+      const specialSteps = ['unknown-step']
+
+      await runSpecialSteps(mockEnvironment, mockOptions, specialSteps)
+
+      expect(mockEnvironment.error).toHaveBeenCalledWith(
+        'Special step unknown-step not found',
+      )
+    })
+  })
+})

package/tests/template-context.test.ts

@@ -0,0 +1,314 @@
+import { describe, expect, it } from 'vitest'
+
+import { createMemoryEnvironment } from '../src/environment.js'
+import { createTemplateFile } from '../src/template-file.js'
+
+import type { AddOn, 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('Template Context - Add-on Options', () => {
+  it('should provide addOnOption context variable', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile('./test.txt.ejs', 'Database: <%= addOnOption.testAddon.database %>')
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Database: postgres')
+  })
+
+  it('should handle multiple add-on options', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'mysql'
+        },
+        shadcn: {
+          theme: 'slate'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'Drizzle: <%= addOnOption.testAddon.database %>, shadcn: <%= addOnOption.shadcn.theme %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Drizzle: mysql, shadcn: slate')
+  })
+
+  it('should handle multiple options per add-on', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        'complex-addon': {
+          database: 'postgres',
+          theme: 'dark',
+          port: 5432
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'DB: <%= addOnOption["complex-addon"].database %>, Theme: <%= addOnOption["complex-addon"].theme %>, Port: <%= addOnOption["complex-addon"].port %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('DB: postgres, Theme: dark, Port: 5432')
+  })
+
+  it('should handle conditional logic with addOnOption', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      `<% if (addOnOption.testAddon.database === 'postgres') { %>
+PostgreSQL configuration
+<% } else if (addOnOption.testAddon.database === 'mysql') { %>
+MySQL configuration
+<% } else { %>
+SQLite configuration
+<% } %>`
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt'].trim()).toEqual('PostgreSQL configuration')
+  })
+
+  it('should handle ignoreFile() with option conditions', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './postgres-config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL configuration\nexport const config = "postgres"'
+    )
+    await templateFile(
+      './mysql-config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL configuration\nexport const config = "mysql"'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/postgres-config.ts']).toBeDefined()
+    expect(output.files['/test/postgres-config.ts'].trim()).toEqual('// PostgreSQL configuration\nexport const config = \'postgres\'')
+    expect(output.files['/test/mysql-config.ts']).toBeUndefined()
+  })
+
+  it('should handle empty addOnOptions', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {}
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'Options: <%= JSON.stringify(addOnOption) %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Options: {}')
+  })
+
+  it('should handle undefined option values', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: undefined
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'Database: <%= addOnOption.testAddon.database || "not set" %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Database: not set')
+  })
+
+  it('should work alongside existing template variables', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      projectName: 'my-app',
+      chosenAddOns: [
+        {
+          id: 'testAddon',
+          name: 'Drizzle ORM',
+        } as AddOn
+      ],
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'Project: <%= projectName %>, Add-ons: <%= Object.keys(addOnEnabled).join(", ") %>, Database: <%= addOnOption.testAddon.database %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Project: my-app, Add-ons: testAddon, Database: postgres')
+  })
+
+  it('should handle nested object access safely', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './test.txt.ejs',
+      'Exists: <%= addOnOption.testAddon ? "yes" : "no" %>, Non-existent: <%= addOnOption.nonexistent ? "yes" : "no" %>'
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/test.txt']).toEqual('Exists: yes, Non-existent: no')
+  })
+
+  it('should handle option-based conditional imports', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'postgres'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './db-config.ts.ejs',
+      `<% if (addOnOption.testAddon.database === 'postgres') { %>
+import { testAddon } from 'testAddon-orm/postgres-js'
+import postgres from 'postgres'
+<% } else if (addOnOption.testAddon.database === 'mysql') { %>
+import { testAddon } from 'testAddon-orm/mysql2'
+import mysql from 'mysql2/promise'
+<% } else if (addOnOption.testAddon.database === 'sqlite') { %>
+import { testAddon } from 'testAddon-orm/better-sqlite3'
+import Database from 'better-sqlite3'
+<% } %>
+
+export const db = testAddon(/* connection */)`
+    )
+    environment.finishRun()
+
+    expect(output.files['/test/db-config.ts']).toContain("import { testAddon } from 'testAddon-orm/postgres-js'")
+    expect(output.files['/test/db-config.ts']).toContain("import postgres from 'postgres'")
+    expect(output.files['/test/db-config.ts']).not.toContain("import mysql from 'mysql2/promise'")
+    expect(output.files['/test/db-config.ts']).not.toContain("import Database from 'better-sqlite3'")
+  })
+
+  it('should handle filename prefix stripping', 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 Drizzle config\nexport default { driver: "postgres" }'
+    )
+    await templateFile(
+      './__mysql__testAddon.config.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "mysql") { ignoreFile() } %>\n// MySQL Drizzle config\nexport default { driver: "mysql" }'
+    )
+    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 Drizzle config\nexport default { driver: \'postgres\' }')
+    
+    // Prefixed filename should not exist
+    expect(output.files['/test/__postgres__testAddon.config.ts']).toBeUndefined()
+    expect(output.files['/test/__mysql__testAddon.config.ts']).toBeUndefined()
+  })
+
+  it('should handle nested directory with prefixed files', async () => {
+    const { environment, output } = createMemoryEnvironment()
+    const templateFile = createTemplateFile(environment, {
+      ...simpleOptions,
+      addOnOptions: {
+        testAddon: {
+          database: 'sqlite'
+        }
+      }
+    })
+    environment.startRun()
+    await templateFile(
+      './src/db/__sqlite__index.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "sqlite") { ignoreFile() } %>\n// SQLite database connection\nexport const db = "sqlite"'
+    )
+    await templateFile(
+      './src/db/__postgres__index.ts.ejs',
+      '<% if (addOnOption.testAddon.database !== "postgres") { ignoreFile() } %>\n// PostgreSQL database connection\nexport const db = "postgres"'
+    )
+    environment.finishRun()
+
+    // SQLite file should be created with prefix stripped
+    expect(output.files['/test/src/db/index.ts']).toBeDefined()
+    expect(output.files['/test/src/db/index.ts'].trim()).toEqual('// SQLite database connection\nexport const db = \'sqlite\'')
+    
+    // Prefixed filenames should not exist
+    expect(output.files['/test/src/db/__sqlite__index.ts']).toBeUndefined()
+    expect(output.files['/test/src/db/__postgres__index.ts']).toBeUndefined()
+  })
+})