@tanstack/cli 0.0.8 → 0.48.2

package/src/engine/custom-addons/shared.ts

@@ -1,281 +0,0 @@
-/**
- * Shared utilities for custom integration/template creation
- * Based on Jack's implementation in create-tsrouter-app
- */
-import { readdir } from 'node:fs/promises'
-import { existsSync, readFileSync } from 'node:fs'
-import { basename, extname, resolve } from 'node:path'
-import ignore from 'ignore'
-import parseGitignore from 'parse-gitignore'
-
-import { compile } from '../compile.js'
-import { readConfigFile } from '../config-file.js'
-import { fetchIntegrations } from '../../api/fetch.js'
-
-import type { PersistedOptions } from '../config-file.js'
-import type { CompileOptions, CompileOutput, IntegrationCompiled } from '../types.js'
-
-// Files to always ignore (from Jack's IGNORE_FILES)
-const IGNORE_FILES = [
-  '.template',
-  '.integration',
-  '.tanstack.json',
-  '.git',
-  'integration-info.json',
-  'integration.json',
-  'build',
-  'bun.lock',
-  'bun.lockb',
-  'deno.lock',
-  'dist',
-  'node_modules',
-  'package-lock.json',
-  'pnpm-lock.yaml',
-  'template.json',
-  'template-info.json',
-  'yarn.lock',
-]
-
-const PROJECT_FILES = ['package.json']
-
-const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico']
-
-/**
- * Check if a file is binary based on extension
- */
-function isBinaryFile(path: string): boolean {
-  return BINARY_EXTENSIONS.includes(extname(path))
-}
-
-/**
- * Read file contents, handling binary files with base64 encoding
- */
-export function readFileHelper(path: string): string {
-  if (isBinaryFile(path)) {
-    return `base64::${readFileSync(path).toString('base64')}`
-  }
-  return readFileSync(path, 'utf-8')
-}
-
-/**
- * Create an ignore function that respects .gitignore and standard ignore patterns
- * Ported from Jack's createIgnore in file-helpers.ts
- */
-export function createIgnore(
-  path: string,
-  includeProjectFiles = true,
-): (filePath: string) => boolean {
-  const gitignorePath = resolve(path, '.gitignore')
-  const ignoreList = existsSync(gitignorePath)
-    ? (
-        parseGitignore(readFileSync(gitignorePath)) as unknown as {
-          patterns: Array<string>
-        }
-      ).patterns
-    : []
-
-  const ig = ignore().add(ignoreList)
-
-  return (filePath: string) => {
-    const fileName = basename(filePath)
-
-    if (
-      IGNORE_FILES.includes(fileName) ||
-      (includeProjectFiles && PROJECT_FILES.includes(fileName))
-    ) {
-      return true
-    }
-
-    const nameWithoutDotSlash = fileName.replace(/^\.\//, '')
-    return ig.ignores(nameWithoutDotSlash)
-  }
-}
-
-/**
- * Create package.json additions by comparing original and current
- * Ported from Jack's createPackageAdditions
- */
-export function createPackageAdditions(
-  originalPackageJson: Record<string, unknown>,
-  currentPackageJson: Record<string, unknown>,
-): {
-  scripts?: Record<string, string>
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-} {
-  const packageAdditions: {
-    scripts?: Record<string, string>
-    dependencies?: Record<string, string>
-    devDependencies?: Record<string, string>
-  } = {}
-
-  const origScripts = (originalPackageJson.scripts || {}) as Record<string, string>
-  const currScripts = (currentPackageJson.scripts || {}) as Record<string, string>
-  const scripts: Record<string, string> = {}
-  for (const script of Object.keys(currScripts)) {
-    const currValue = currScripts[script]
-    if (currValue && origScripts[script] !== currValue) {
-      scripts[script] = currValue
-    }
-  }
-  if (Object.keys(scripts).length) {
-    packageAdditions.scripts = scripts
-  }
-
-  const origDeps = (originalPackageJson.dependencies || {}) as Record<string, string>
-  const currDeps = (currentPackageJson.dependencies || {}) as Record<string, string>
-  const dependencies: Record<string, string> = {}
-  for (const dep of Object.keys(currDeps)) {
-    const currValue = currDeps[dep]
-    if (currValue && origDeps[dep] !== currValue) {
-      dependencies[dep] = currValue
-    }
-  }
-  if (Object.keys(dependencies).length) {
-    packageAdditions.dependencies = dependencies
-  }
-
-  const origDevDeps = (originalPackageJson.devDependencies || {}) as Record<string, string>
-  const currDevDeps = (currentPackageJson.devDependencies || {}) as Record<string, string>
-  const devDependencies: Record<string, string> = {}
-  for (const dep of Object.keys(currDevDeps)) {
-    const currValue = currDevDeps[dep]
-    if (currValue && origDevDeps[dep] !== currValue) {
-      devDependencies[dep] = currValue
-    }
-  }
-  if (Object.keys(devDependencies).length) {
-    packageAdditions.devDependencies = devDependencies
-  }
-
-  return packageAdditions
-}
-
-export async function createCompileOptionsFromPersisted(
-  persisted: PersistedOptions,
-  integrationsPath?: string,
-): Promise<CompileOptions> {
-  let chosenIntegrations: Array<IntegrationCompiled> = []
-  if (persisted.chosenIntegrations.length > 0) {
-    chosenIntegrations = await fetchIntegrations(persisted.chosenIntegrations, integrationsPath)
-  }
-
-  return {
-    projectName: persisted.projectName,
-    framework: persisted.framework,
-    mode: persisted.mode,
-    typescript: persisted.typescript,
-    tailwind: persisted.tailwind,
-    packageManager: persisted.packageManager,
-    chosenIntegrations,
-    integrationOptions: {},
-    customTemplate: undefined,
-  }
-}
-
-export function runCompile(options: CompileOptions): CompileOutput {
-  return compile(options)
-}
-
-/**
- * Compare files recursively between current project and original output
- * Ported from Jack's compareFilesRecursively
- */
-export async function compareFilesRecursively(
-  basePath: string,
-  ignoreFn: (filePath: string) => boolean,
-  original: Record<string, string>,
-  changedFiles: Record<string, string>,
-): Promise<void> {
-  await compareFilesRecursivelyHelper(basePath, '.', ignoreFn, original, changedFiles)
-}
-
-async function compareFilesRecursivelyHelper(
-  basePath: string,
-  relativePath: string,
-  ignoreFn: (filePath: string) => boolean,
-  original: Record<string, string>,
-  changedFiles: Record<string, string>,
-): Promise<void> {
-  const fullPath = resolve(basePath, relativePath)
-  const entries = await readdir(fullPath, { withFileTypes: true })
-
-  for (const entry of entries) {
-    const entryRelativePath = relativePath === '.' ? entry.name : `${relativePath}/${entry.name}`
-    const entryFullPath = resolve(basePath, entryRelativePath)
-
-    if (ignoreFn(entry.name)) {
-      continue
-    }
-
-    if (entry.isDirectory()) {
-      await compareFilesRecursivelyHelper(basePath, entryRelativePath, ignoreFn, original, changedFiles)
-    } else {
-      const contents = readFileHelper(entryFullPath)
-      // Original files use paths without ./ prefix
-      const originalKey = entryRelativePath
-
-      if (!original[originalKey] || original[originalKey] !== contents) {
-        changedFiles[entryRelativePath] = contents
-      }
-    }
-  }
-}
-
-export async function readCurrentProjectOptions(
-  targetDir: string,
-): Promise<PersistedOptions> {
-  const persisted = await readConfigFile(targetDir)
-  if (!persisted) {
-    throw new Error(
-      `No .tanstack.json file found in ${targetDir}.\n` +
-        `This project may have been created with an older version of the CLI, ` +
-        `or was not created with the TanStack CLI.`,
-    )
-  }
-  return persisted
-}
-
-/**
- * Recursively gather files from a directory
- * Ported from Jack's recursivelyGatherFiles
- */
-export async function recursivelyGatherFiles(
-  path: string,
-  includeProjectFiles = true,
-): Promise<Record<string, string>> {
-  const ignoreFn = createIgnore(path, includeProjectFiles)
-  const files: Record<string, string> = {}
-
-  if (!existsSync(path)) {
-    return files
-  }
-
-  await gatherFilesHelper(path, '.', files, ignoreFn)
-  return files
-}
-
-async function gatherFilesHelper(
-  basePath: string,
-  relativePath: string,
-  files: Record<string, string>,
-  ignoreFn: (filePath: string) => boolean,
-): Promise<void> {
-  const fullPath = resolve(basePath, relativePath)
-  const entries = await readdir(fullPath, { withFileTypes: true })
-
-  for (const entry of entries) {
-    if (ignoreFn(entry.name)) {
-      continue
-    }
-
-    const entryRelativePath = relativePath === '.' ? entry.name : `${relativePath}/${entry.name}`
-    const entryFullPath = resolve(basePath, entryRelativePath)
-
-    if (entry.isDirectory()) {
-      await gatherFilesHelper(basePath, entryRelativePath, files, ignoreFn)
-    } else {
-      files[entryRelativePath] = readFileHelper(entryFullPath)
-    }
-  }
-}

package/src/engine/custom-addons/template.test.ts

@@ -1,288 +0,0 @@
-import { resolve } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { fetchIntegrations } from '../../api/fetch.js'
-import { compile } from '../compile.js'
-import { CustomTemplateCompiledSchema } from '../types.js'
-import type { CustomTemplateCompiled } from '../types.js'
-
-const INTEGRATIONS_PATH = resolve(__dirname, '../../../../../integrations')
-
-describe('Custom template schema', () => {
-  it('should validate a minimal template', () => {
-    const template = {
-      id: 'my-template',
-      name: 'My Template',
-      description: 'A simple template',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: [],
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(true)
-  })
-
-  it('should validate a template with integrations', () => {
-    const template = {
-      id: 'saas-template',
-      name: 'SaaS Template',
-      description: 'Complete SaaS setup',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: ['tanstack-query', 'clerk', 'drizzle', 'shadcn'],
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.integrations).toHaveLength(4)
-    }
-  })
-
-  it('should validate a template with integration options', () => {
-    const template = {
-      id: 'db-template',
-      name: 'Database Template',
-      description: 'Template with database preset',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: ['drizzle'],
-      integrationOptions: {
-        drizzle: {
-          database: 'postgres',
-        },
-      },
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.integrationOptions?.drizzle).toEqual({ database: 'postgres' })
-    }
-  })
-
-  it('should validate a template with banner', () => {
-    const template = {
-      id: 'branded-template',
-      name: 'Branded Template',
-      description: 'A branded template',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: false,
-      integrations: [],
-      banner: 'https://example.com/banner.png',
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(true)
-  })
-
-  it('should reject template without required fields', () => {
-    const template = {
-      id: 'incomplete',
-      name: 'Incomplete',
-      // missing: description, framework, mode, typescript, tailwind, integrations
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(false)
-  })
-
-  it('should reject template with invalid mode', () => {
-    const template = {
-      id: 'invalid-mode',
-      name: 'Invalid Mode',
-      description: 'Has invalid mode',
-      framework: 'react',
-      mode: 'invalid-mode', // should be 'file-router' or 'code-router'
-      typescript: true,
-      tailwind: true,
-      integrations: [],
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(false)
-  })
-
-  it('should allow code-router mode', () => {
-    const template = {
-      id: 'code-router-template',
-      name: 'Code Router Template',
-      description: 'Uses code router',
-      framework: 'react',
-      mode: 'code-router',
-      typescript: true,
-      tailwind: true,
-      integrations: [],
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(template)
-    expect(result.success).toBe(true)
-  })
-})
-
-describe('Custom template as integration preset', () => {
-  it('templates should NOT have files property', () => {
-    const templateWithFiles = {
-      id: 'files-template',
-      name: 'Files Template',
-      description: 'Tries to have files',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: [],
-      files: { 'src/custom.ts': 'export const x = 1' }, // should be rejected
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(templateWithFiles)
-    // Zod strips unknown keys by default, so this passes but files is removed
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect((result.data as Record<string, unknown>).files).toBeUndefined()
-    }
-  })
-
-  it('templates should NOT have packageAdditions property', () => {
-    const templateWithPackages = {
-      id: 'packages-template',
-      name: 'Packages Template',
-      description: 'Tries to have packages',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: [],
-      packageAdditions: { dependencies: { foo: '1.0.0' } }, // should be stripped
-    }
-
-    const result = CustomTemplateCompiledSchema.safeParse(templateWithPackages)
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect((result.data as Record<string, unknown>).packageAdditions).toBeUndefined()
-    }
-  })
-})
-
-describe('Custom template end-to-end flow', () => {
-  it('should resolve template integrations and compile project', async () => {
-    // Simulate what the create command does
-    const template: CustomTemplateCompiled = {
-      id: 'test-template',
-      name: 'Test Template',
-      description: 'Test template with real integrations',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: ['tanstack-query', 'tanstack-form'],
-    }
-
-    // Fetch the integrations specified in the template
-    const chosenIntegrations = await fetchIntegrations(template.integrations, INTEGRATIONS_PATH)
-    expect(chosenIntegrations).toHaveLength(2)
-
-    // Compile with the template
-    const output = compile({
-      projectName: 'template-test-project',
-      framework: template.framework,
-      mode: template.mode,
-      typescript: template.typescript,
-      tailwind: template.tailwind,
-      packageManager: 'pnpm',
-      chosenIntegrations,
-      integrationOptions: template.integrationOptions ?? {},
-      customTemplate: template,
-    })
-
-    // Verify base files exist
-    expect(output.files).toHaveProperty('package.json')
-    expect(output.files).toHaveProperty('vite.config.ts')
-
-    // Verify integration files are included
-    expect(output.files).toHaveProperty('src/integrations/query/provider.tsx')
-    expect(output.files).toHaveProperty('src/routes/demo/query.tsx')
-    expect(output.files).toHaveProperty('src/routes/demo/form.tsx')
-
-    // Verify integration dependencies are merged
-    const pkg = JSON.parse(output.files['package.json']!)
-    expect(pkg.dependencies).toHaveProperty('@tanstack/react-query')
-    expect(pkg.dependencies).toHaveProperty('@tanstack/react-form')
-  })
-
-  it('should respect template integration options', async () => {
-    const template: CustomTemplateCompiled = {
-      id: 'options-template',
-      name: 'Options Template',
-      description: 'Template with preset options',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: true,
-      integrations: ['drizzle'],
-      integrationOptions: {
-        drizzle: {
-          database: 'sqlite',
-        },
-      },
-    }
-
-    const chosenIntegrations = await fetchIntegrations(template.integrations, INTEGRATIONS_PATH)
-
-    const output = compile({
-      projectName: 'options-test',
-      framework: template.framework,
-      mode: template.mode,
-      typescript: template.typescript,
-      tailwind: template.tailwind,
-      packageManager: 'pnpm',
-      chosenIntegrations,
-      integrationOptions: template.integrationOptions ?? {},
-      customTemplate: template,
-    })
-
-    // The integration options should be available for template processing
-    // (actual option handling depends on the integration's template files)
-    expect(output.files).toHaveProperty('package.json')
-  })
-
-  it('should work with empty integration list', () => {
-    const template: CustomTemplateCompiled = {
-      id: 'minimal-template',
-      name: 'Minimal Template',
-      description: 'Just the defaults',
-      framework: 'react',
-      mode: 'file-router',
-      typescript: true,
-      tailwind: false, // no tailwind
-      integrations: [],
-    }
-
-    const output = compile({
-      projectName: 'minimal-test',
-      framework: template.framework,
-      mode: template.mode,
-      typescript: template.typescript,
-      tailwind: template.tailwind,
-      packageManager: 'pnpm',
-      chosenIntegrations: [],
-      integrationOptions: {},
-      customTemplate: template,
-    })
-
-    // Base files should exist
-    expect(output.files).toHaveProperty('package.json')
-    expect(output.files).toHaveProperty('vite.config.ts')
-
-    // Tailwind should NOT be in the output
-    const viteConfig = output.files['vite.config.ts']!
-    expect(viteConfig).not.toContain('tailwindcss')
-  })
-})

package/src/engine/custom-addons/template.ts

@@ -1,124 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { CustomTemplateCompiledSchema } from '../types.js'
-import { readCurrentProjectOptions } from './shared.js'
-
-import type { PersistedOptions } from '../config-file.js'
-import type { CustomTemplateCompiled, CustomTemplateInfo } from '../types.js'
-
-const INFO_FILE = 'template-info.json'
-const COMPILED_FILE = 'template.json'
-
-/**
- * Generate default template info from project options
- * Custom templates are just integration presets - they capture which integrations are selected
- */
-async function readOrGenerateTemplateInfo(
-  options: PersistedOptions,
-  targetDir: string,
-): Promise<CustomTemplateInfo> {
-  const infoPath = resolve(targetDir, INFO_FILE)
-
-  if (existsSync(infoPath)) {
-    const content = await readFile(infoPath, 'utf-8')
-    return JSON.parse(content)
-  }
-
-  return {
-    id: `${options.projectName}-template`,
-    name: `${options.projectName} Template`,
-    description: 'A curated project template',
-
-    framework: options.framework,
-    mode: options.mode,
-    typescript: options.typescript,
-    tailwind: options.tailwind,
-
-    integrations: options.chosenIntegrations,
-  }
-}
-
-/**
- * Compile a custom template from the current project
- * Custom templates are just integration presets - they specify project defaults and which integrations to include
- */
-export async function compileTemplate(
-  targetDir: string,
-): Promise<void> {
-  const persistedOptions = await readCurrentProjectOptions(targetDir)
-  const info = await readOrGenerateTemplateInfo(persistedOptions, targetDir)
-
-  const compiledInfo: CustomTemplateCompiled = {
-    ...info,
-    id: info.id || `${persistedOptions.projectName}-template`,
-  }
-
-  await writeFile(
-    resolve(targetDir, COMPILED_FILE),
-    JSON.stringify(compiledInfo, null, 2),
-  )
-
-  console.log(`Compiled template written to ${COMPILED_FILE}`)
-  console.log(`\nIncluded integrations: ${compiledInfo.integrations.length > 0 ? compiledInfo.integrations.join(', ') : '(none)'}`)
-}
-
-export async function initTemplate(
-  targetDir: string,
-): Promise<void> {
-  const persistedOptions = await readCurrentProjectOptions(targetDir)
-  const info = await readOrGenerateTemplateInfo(persistedOptions, targetDir)
-
-  // Write the info file for editing
-  await writeFile(
-    resolve(targetDir, INFO_FILE),
-    JSON.stringify(info, null, 2),
-  )
-
-  // Compile the template
-  await compileTemplate(targetDir)
-
-  console.log(`
-Custom template initialized successfully!
-
-Files created:
-  ${INFO_FILE} - Template metadata (edit this to customize)
-  ${COMPILED_FILE} - Compiled template (distribute this)
-
-Custom templates are integration presets. They capture:
-  - Project defaults (framework, mode, typescript, tailwind)
-  - Which integrations to include
-  - Preset integration options (if any)
-
-Next steps:
-  1. Edit ${INFO_FILE} to customize name, description, and integrations
-  2. Run 'tanstack template compile' to rebuild after changes
-  3. Share ${COMPILED_FILE} or host it publicly
-  4. Users can use: tanstack create --template <url-to-template.json>
-`)
-}
-
-/**
- * Load a remote custom template from a URL
- */
-export async function loadTemplate(url: string): Promise<CustomTemplateCompiled> {
-  const response = await fetch(url)
-  if (!response.ok) {
-    throw new Error(`Failed to fetch template from ${url}: ${response.statusText}`)
-  }
-
-  const jsonContent = await response.json()
-
-  const result = CustomTemplateCompiledSchema.safeParse(jsonContent)
-  if (!result.success) {
-    throw new Error(`Invalid template at ${url}: ${result.error.message}`)
-  }
-
-  const template = result.data
-  if (!template.id) {
-    template.id = url
-  }
-
-  return template
-}