@tanstack/cta-engine 0.10.0-alpha.21 → 0.10.0-alpha.25

package/src/template-file.ts

@@ -1,150 +0,0 @@
-import { resolve } from 'node:path'
-import { render } from 'ejs'
-import { format } from 'prettier'
-
-import { CODE_ROUTER, FILE_ROUTER } from './constants.js'
-import { formatCommand } from './utils.js'
-import {
-  getPackageManagerInstallCommand,
-  getPackageManagerScriptCommand,
-} from './package-manager.js'
-import { relativePath } from './file-helpers.js'
-
-import type { AddOn, Environment, Options } from './types.js'
-
-function convertDotFilesAndPaths(path: string) {
-  return path
-    .split('/')
-    .map((segment) => segment.replace(/^_dot_/, '.'))
-    .join('/')
-}
-
-export function createTemplateFile(environment: Environment, options: Options) {
-  function getPackageManagerAddScript(
-    packageName: string,
-    isDev: boolean = false,
-  ) {
-    return formatCommand(
-      getPackageManagerInstallCommand(
-        options.packageManager,
-        packageName,
-        isDev,
-      ),
-    )
-  }
-  function getPackageManagerRunScript(
-    scriptName: string,
-    args: Array<string> = [],
-  ) {
-    return formatCommand(
-      getPackageManagerScriptCommand(options.packageManager, [
-        scriptName,
-        ...args,
-      ]),
-    )
-  }
-
-  class IgnoreFileError extends Error {
-    constructor() {
-      super('ignoreFile')
-      this.name = 'IgnoreFileError'
-    }
-  }
-
-  const integrations: Array<Required<AddOn>['integrations'][number]> = []
-  for (const addOn of options.chosenAddOns) {
-    if (addOn.integrations) {
-      for (const integration of addOn.integrations) {
-        integrations.push(integration)
-      }
-    }
-  }
-
-  const routes: Array<Required<AddOn>['routes'][number]> = []
-  for (const addOn of options.chosenAddOns) {
-    if (addOn.routes) {
-      routes.push(...addOn.routes)
-    }
-  }
-
-  const addOnEnabled = options.chosenAddOns.reduce<Record<string, boolean>>(
-    (acc, addOn) => {
-      acc[addOn.id] = true
-      return acc
-    },
-    {},
-  )
-
-  return async function templateFile(file: string, content: string) {
-    const templateValues = {
-      packageManager: options.packageManager,
-      projectName: options.projectName,
-      typescript: options.typescript,
-      tailwind: options.tailwind,
-      js: options.typescript ? 'ts' : 'js',
-      jsx: options.typescript ? 'tsx' : 'jsx',
-      fileRouter: options.mode === FILE_ROUTER,
-      codeRouter: options.mode === CODE_ROUTER,
-      addOnEnabled,
-      addOns: options.chosenAddOns,
-      integrations,
-      routes,
-
-      getPackageManagerAddScript,
-      getPackageManagerRunScript,
-
-      relativePath: (path: string) => relativePath(file, path),
-
-      ignoreFile: () => {
-        throw new IgnoreFileError()
-      },
-    }
-
-    let ignoreFile = false
-
-    if (file.endsWith('.ejs')) {
-      try {
-        content = render(content, templateValues)
-      } catch (error) {
-        if (error instanceof IgnoreFileError) {
-          ignoreFile = true
-        } else {
-          console.error(file, error)
-          environment.error(`EJS error in file ${file}`, error?.toString())
-          process.exit(1)
-        }
-      }
-    }
-
-    if (ignoreFile) {
-      return
-    }
-
-    let target = convertDotFilesAndPaths(file.replace('.ejs', ''))
-
-    let append = false
-    if (target.endsWith('.append')) {
-      append = true
-      target = target.replace('.append', '')
-    }
-
-    if (target.endsWith('.ts') || target.endsWith('.tsx')) {
-      content = await format(content, {
-        semi: false,
-        singleQuote: true,
-        trailingComma: 'all',
-        parser: 'typescript',
-      })
-    }
-
-    if (!options.typescript) {
-      target = target.replace(/\.tsx$/, '.jsx').replace(/\.ts$/, '.js')
-    }
-
-    if (append) {
-      await environment.appendFile(resolve(options.targetDir, target), content)
-    } else {
-      await environment.writeFile(resolve(options.targetDir, target), content)
-    }
-  }
-}

package/tests/add-ons.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { finalizeAddOns, getAllAddOns } from '../src/add-ons.js'
-
-import type { AddOn, Framework } from '../src/types.js'
-
-describe('getAllAddOns', () => {
-  it('filter add-ons', () => {
-    const addOns = getAllAddOns(
-      {
-        id: 'react-cra',
-        getAddOns: () => [
-          {
-            id: 'add-on-1',
-            description: 'Add-on 1',
-            modes: ['file-router'],
-          } as AddOn,
-          {
-            id: 'add-on-2',
-            description: 'Add-on 2',
-            modes: ['code-router'],
-          } as AddOn,
-        ],
-      } as Framework,
-      'file-router',
-    )
-
-    expect(addOns.length).toEqual(1)
-    expect(addOns[0].id).toEqual('add-on-1')
-  })
-})
-
-describe('finalizeAddOns', () => {
-  it('should finalize add-ons', async () => {
-    const addOns = await finalizeAddOns(
-      {
-        id: 'react-cra',
-        getAddOns: () => [
-          {
-            id: 'add-on-1',
-            description: 'Add-on 1',
-            modes: ['file-router'],
-            dependsOn: ['add-on-2'],
-          } as AddOn,
-          {
-            id: 'add-on-2',
-            description: 'Add-on 2',
-            modes: ['file-router'],
-          } as AddOn,
-          {
-            id: 'add-on-3',
-            description: 'Add-on 3',
-            modes: ['file-router'],
-          } as AddOn,
-        ],
-      } as Framework,
-      'file-router',
-      ['add-on-1'],
-    )
-
-    expect(addOns.length).toEqual(2)
-    const addOnIds = addOns.map((a) => a.id)
-    expect(addOnIds.includes('add-on-1')).toEqual(true)
-    expect(addOnIds.includes('add-on-2')).toEqual(true)
-    expect(addOnIds.includes('add-on-3')).toEqual(false)
-  })
-})

package/tests/add-to-app.test.ts

@@ -1,358 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-
-import { createMemoryEnvironment } from '../src/environment.js'
-import {
-  addToApp,
-  getCurrentConfiguration,
-  hasPendingGitChanges,
-  runNewCommands,
-  writeFiles,
-} from '../src/add-to-app.js'
-import {
-  __testClearFrameworks,
-  __testRegisterFramework,
-} from '../src/frameworks.js'
-
-import type { PersistedOptions } from '../src/config-file.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-const fakeCTAJSON: PersistedOptions = {
-  projectName: 'test',
-  targetDir: '/foo',
-  framework: 'test',
-  mode: 'code-router',
-  existingAddOns: [],
-  version: 1,
-  typescript: true,
-  tailwind: true,
-  packageManager: 'npm',
-  git: true,
-}
-
-beforeEach(() => {
-  const fakeFiles = {
-    './package.json': JSON.stringify({
-      name: 'test',
-      version: '1.0.0',
-      dependencies: {},
-    }),
-  }
-
-  vol.reset()
-  __testClearFrameworks()
-  __testRegisterFramework({
-    id: 'test',
-    name: 'Test',
-    description: 'Test',
-    version: '1.0.0',
-    baseDirectory: '/foo',
-    addOnsDirectories: [],
-    examplesDirectory: '',
-    basePackageJSON: {},
-    optionalPackages: {},
-    getAddOns: () => [
-      {
-        id: 'test',
-        name: 'Test',
-        description: 'Test',
-        version: '1.0.0',
-        type: 'add-on',
-        phase: 'add-on',
-        modes: ['code-router', 'file-router'],
-        command: {
-          command: 'echo',
-          args: ['baz'],
-        },
-        packageAdditions: {
-          dependencies: {
-            'test-package': '1.0.0',
-          },
-        },
-        dependsOn: [],
-        getFiles: () => Promise.resolve(['./jack.txt']),
-        getFileContents: () => Promise.resolve('foo'),
-        getDeletedFiles: () => Promise.resolve([]),
-      },
-    ],
-    getFiles: () => Promise.resolve(Object.keys(fakeFiles)),
-    getFileContents: (path) => Promise.resolve(fakeFiles[path]),
-    getDeletedFiles: () => Promise.resolve([]),
-  })
-})
-
-const configFile: PersistedOptions = {
-  projectName: 'test',
-  targetDir: '/foo',
-  framework: 'test',
-  mode: 'code-router',
-  existingAddOns: [],
-  version: 1,
-  typescript: true,
-  tailwind: true,
-  packageManager: 'npm',
-  git: true,
-}
-
-describe('getCurrentConfiguration', () => {
-  it('should check for the config file', async () => {
-    const { environment } = createMemoryEnvironment()
-    const out = await getCurrentConfiguration(environment, '/foo')
-    expect(out).toBeUndefined()
-  })
-
-  it('should read the config file', async () => {
-    const { environment } = createMemoryEnvironment()
-
-    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
-
-    const out = await getCurrentConfiguration(environment, '/foo')
-    expect(out).toEqual(configFile)
-  })
-})
-
-describe('hasPendingGitChanges', () => {
-  it('should check for pending git changes', async () => {
-    const { environment } = createMemoryEnvironment()
-    environment.execute = () => Promise.resolve({ stdout: '' })
-    const out = await hasPendingGitChanges(environment, '/foo')
-    expect(out).toBe(false)
-  })
-
-  it('should check for pending git changes', async () => {
-    const { environment } = createMemoryEnvironment()
-    environment.execute = () => Promise.resolve({ stdout: 'M foo' })
-    const out = await hasPendingGitChanges(environment, '/foo')
-    expect(out).toBe(true)
-  })
-})
-
-describe('writeFiles', () => {
-  it('should prompt for confirmation when not forced', async () => {
-    const { environment } = createMemoryEnvironment('/foo')
-    environment.writeFile('/foo/bloop.txt', 'bloop')
-    environment.writeFile(
-      '/foo/package.json',
-      JSON.stringify(
-        {
-          name: 'test',
-          version: '1.0.0',
-          dependencies: {},
-        },
-        null,
-        2,
-      ),
-    )
-    environment.writeFile('/foo/bar.txt', 'bar')
-    environment.confirm = () => Promise.resolve(false)
-    let thrown = false
-    writeFiles(
-      environment,
-      '/foo',
-      {
-        files: {
-          './bar.txt': 'baz',
-          './blarg.txt': 'blarg',
-        },
-        deletedFiles: [],
-      },
-      false,
-    )
-      .catch((e) => {
-        thrown = true
-      })
-      .finally(() => {
-        expect(thrown).toBe(true)
-      })
-  })
-
-  it('should not prompt for confirmation when forced', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
-    environment.writeFile('/foo/blooop.txt', 'blooop')
-    await writeFiles(
-      environment,
-      '/foo',
-      {
-        files: {
-          './bar.txt': 'baz',
-          './blarg.txt': 'blarg',
-        },
-        deletedFiles: [],
-      },
-      true,
-    )
-    environment.finishRun()
-    expect(output.files).toEqual({
-      './blooop.txt': 'blooop',
-      './bar.txt': 'baz',
-      './blarg.txt': 'blarg',
-    })
-  })
-
-  it('should handle binary files', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    environment.writeFile('/foo/.cta.json', JSON.stringify(configFile, null, 2))
-    environment.writeFile('/foo/unchanged.jpg', 'base64::foobaz')
-    environment.writeFile('/foo/changing.jpg', 'base64::foobaz')
-    await writeFiles(
-      environment,
-      '/foo',
-      {
-        files: {
-          './unchanged.jpg': 'base64::foobaz',
-          './changing.jpg': 'base64::aGVsbG8=',
-          './new.jpg': 'base64::aGVsbG8=',
-        },
-        deletedFiles: [],
-      },
-      true,
-    )
-    environment.finishRun()
-    // It's ok for unchanged.jpg not to be written, because it matches the existing file
-    expect(output.files).toEqual({
-      './unchanged.jpg': 'base64::foobaz',
-      './changing.jpg': 'base64::aGVsbG8=',
-      './new.jpg': 'base64::aGVsbG8=',
-    })
-  })
-
-  it('should handle package.json', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    environment.writeFile(
-      '/foo/package.json',
-      JSON.stringify(
-        {
-          name: 'test',
-          version: '1.0.0',
-          scripts: {
-            dev: 'echo "test"',
-          },
-          dependencies: {
-            'test-package-2': '1.0.0',
-          },
-        },
-        null,
-        2,
-      ),
-    )
-    await writeFiles(
-      environment,
-      '/foo',
-      {
-        files: {
-          './package.json': JSON.stringify(
-            {
-              scripts: {
-                test: 'echo "test"',
-              },
-              dependencies: {
-                'test-package': '1.0.0',
-              },
-            },
-            null,
-            2,
-          ),
-        },
-        deletedFiles: [],
-      },
-      true,
-    )
-    environment.finishRun()
-    expect(output.files).toEqual({
-      './package.json': JSON.stringify(
-        {
-          name: 'test',
-          version: '1.0.0',
-          scripts: {
-            dev: 'echo "test"',
-            test: 'echo "test"',
-          },
-          dependencies: {
-            'test-package-2': '1.0.0',
-            'test-package': '1.0.0',
-          },
-          devDependencies: {},
-        },
-        null,
-        2,
-      ),
-    })
-  })
-
-  it('should delete files', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    environment.writeFile('/foo/bloop.txt', 'bloop')
-    await writeFiles(
-      environment,
-      '/foo',
-      { files: {}, deletedFiles: ['./bloop.txt'] },
-      true,
-    )
-    environment.finishRun()
-    expect(output.deletedFiles).toEqual(['./bloop.txt'])
-  })
-})
-
-describe('runNewCommands', () => {
-  it('should run new commands', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    await runNewCommands(environment, fakeCTAJSON, '/foo', {
-      commands: [{ command: 'echo', args: ['bloop'] }],
-    })
-    environment.finishRun()
-    expect(output.commands).toEqual([{ command: 'echo', args: ['bloop'] }])
-  })
-})
-
-describe('addToApp', () => {
-  it('should add an add-on', async () => {
-    const { environment, output } = createMemoryEnvironment('/foo')
-    environment.startRun()
-    environment.writeFile(
-      '/foo/.cta.json',
-      JSON.stringify(fakeCTAJSON, null, 2),
-    )
-    environment.writeFile(
-      '/foo/package.json',
-      JSON.stringify(
-        {
-          name: 'test',
-          version: '1.0.0',
-          scripts: {},
-          dependencies: {},
-          devDependencies: {},
-        },
-        null,
-        2,
-      ),
-    )
-    await addToApp(environment, ['test'], '/foo', {
-      forced: true,
-    })
-    environment.finishRun()
-    expect(output.files).toEqual({
-      './jack.txt': 'foo',
-      './package.json': JSON.stringify(
-        {
-          name: 'test',
-          version: '1.0.0',
-          scripts: {},
-          dependencies: {
-            'test-package': '1.0.0',
-          },
-          devDependencies: {},
-        },
-        null,
-        2,
-      ),
-    })
-  })
-})

package/tests/config-file.test.ts

@@ -1,68 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { fs, vol } from 'memfs'
-import { resolve } from 'node:path'
-
-import {
-  readConfigFileFromEnvironment,
-  writeConfigFileToEnvironment,
-} from '../src/config-file.js'
-import { CONFIG_FILE } from '../src/constants.js'
-import { createMemoryEnvironment } from '../src/environment.js'
-import type { AddOn, Environment, Framework, Options } from '../src/types.js'
-
-vi.mock('node:fs', () => fs)
-vi.mock('node:fs/promises', () => fs.promises)
-
-beforeEach(() => {
-  vol.reset()
-})
-
-describe('writeConfigFile', () => {
-  it('should write the config file', async () => {
-    const targetDir = 'test-dir'
-    const options = {
-      framework: {
-        id: 'react-cra',
-        getAddOns: () => [],
-      } as unknown as Framework,
-      chosenAddOns: [
-        {
-          id: 'add-on-1',
-          description: 'Add-on 1',
-          modes: ['file-router'],
-        } as AddOn,
-      ],
-      targetDir,
-    } as unknown as Options
-    const persistedOptions = {
-      version: 1,
-      framework: options.framework.id,
-      existingAddOns: options.chosenAddOns.map((addOn) => addOn.id),
-    }
-    const env = {
-      writeFile: (path, optionsString) => {
-        expect(path).toEqual(resolve(targetDir, CONFIG_FILE))
-        expect(optionsString).toEqual(JSON.stringify(persistedOptions, null, 2))
-      },
-    } as Environment
-    await writeConfigFileToEnvironment(env, options)
-  })
-})
-
-describe('readConfigFileFromEnvironment', () => {
-  it('should read the config file', async () => {
-    const targetDir = 'test-dir'
-    const persistedOptions = {
-      version: 1,
-      framework: 'react-cra',
-      existingAddOns: ['add-on-1'],
-    }
-    const { environment } = createMemoryEnvironment()
-    environment.writeFile(
-      resolve(targetDir, CONFIG_FILE),
-      JSON.stringify(persistedOptions, null, 2),
-    )
-    const config = await readConfigFileFromEnvironment(environment, targetDir)
-    expect(config).toEqual(persistedOptions)
-  })
-})