Skip to content
Source
Sign inSign up
TanStack/cli
Open History to see the last commit

create-app.ts

288 lines8.3 KB

1import { basename, resolve } from 'node:path'
2​
3import { isBase64 } from './file-helpers.js'
4import { formatCommand } from './utils.js'
5import { writeConfigFileToEnvironment } from './config-file.js'
6import {
7 getPackageManagerScriptCommand,
8 packageManagerInstall,
9} from './package-manager.js'
10import { createPackageJSON } from './package-json.js'
11import { createTemplateFile } from './template-file.js'
12import { installShadcnComponents } from './integrations/shadcn.js'
13import { setupGit } from './integrations/git.js'
14import { runSpecialSteps } from './special-steps/index.js'
15​
16import type { Environment, FileBundleHandler, Options } from './types.js'
17​
18async function writeFiles(environment: Environment, options: Options) {
19 const templateFileFromContent = createTemplateFile(environment, options)
20​
21 async function writeFileBundle(bundle: FileBundleHandler) {
22 const files = await bundle.getFiles()
23​
24 for (const file of files) {
25 const contents = await bundle.getFileContents(file)
26​
27 const isBinaryFile = isBase64(contents)
28 if (isBinaryFile) {
29 await environment.writeFileBase64(
30 resolve(options.targetDir, file),
31 contents,
32 )
33 } else {
34 await templateFileFromContent(file, contents)
35 }
36 }
37​
38 const deletedFiles = await bundle.getDeletedFiles()
39 for (const file of deletedFiles) {
40 await environment.deleteFile(resolve(options.targetDir, file))
41 }
42 }
43​
44 environment.startStep({
45 id: 'write-framework-files',
46 type: 'file',
47 message: 'Writing framework files...',
48 })
49 await writeFileBundle(options.framework)
50 environment.finishStep('write-framework-files', 'Framework files written')
51​
52 let wroteAddonFiles = false
53 for (const type of ['add-on', 'example', 'toolchain', 'deployment']) {
54 for (const phase of ['setup', 'add-on', 'example']) {
55 for (const addOn of options.chosenAddOns.filter(
56 (addOn) => addOn.phase === phase && addOn.type === type,
57 )) {
58 environment.startStep({
59 id: 'write-addon-files',
60 type: 'file',
61 message: `Writing ${addOn.name} files...`,
62 })
63 await writeFileBundle(addOn)
64 wroteAddonFiles = true
65 }
66 }
67 }
68 if (wroteAddonFiles) {
69 environment.finishStep('write-addon-files', 'Add-on files written')
70 }
71​
72 if (options.starter) {
73 environment.startStep({
74 id: 'write-starter-files',
75 type: 'file',
76 message: 'Writing starter files...',
77 })
78 await writeFileBundle(options.starter)
79 environment.finishStep('write-starter-files', 'Starter files written')
80 }
81​
82 environment.startStep({
83 id: 'write-package-json',
84 type: 'file',
85 message: 'Writing package.json...',
86 })
87 await environment.writeFile(
88 resolve(options.targetDir, './package.json'),
89 JSON.stringify(createPackageJSON(options), null, 2),
90 )
91 environment.finishStep('write-package-json', 'Package.json written')
92​
93 environment.startStep({
94 id: 'write-config-file',
95 type: 'file',
96 message: 'Writing config file...',
97 })
98 await writeConfigFileToEnvironment(environment, options)
99 environment.finishStep('write-config-file', 'Config file written')
101​
102async function runCommandsAndInstallDependencies(
103 environment: Environment,
104 options: Options,
105) {
106 const s = environment.spinner()
107​
108 // Setup git
109 if (options.git) {
110 s.start(`Initializing git repository...`)
111 environment.startStep({
112 id: 'initialize-git-repository',
113 type: 'command',
114 message: 'Initializing git repository...',
115 })
116​
117 await setupGit(environment, options.targetDir)
118​
119 environment.finishStep(
120 'initialize-git-repository',
121 'Initialized git repository',
122 )
123 s.stop(`Initialized git repository`)
124 }
125​
126 // Run any special steps for the new add-ons
127 const specialSteps = new Set<string>([])
128 for (const addOn of options.chosenAddOns) {
129 for (const step of addOn.createSpecialSteps || []) {
130 specialSteps.add(step)
131 }
132 }
133 if (specialSteps.size) {
134 await runSpecialSteps(environment, options, Array.from(specialSteps))
135 }
136​
137 // Install dependencies
138 if (options.install !== false) {
139 s.start(`Installing dependencies via ${options.packageManager}...`)
140 environment.startStep({
141 id: 'install-dependencies',
142 type: 'package-manager',
143 message: `Installing dependencies via ${options.packageManager}...`,
144 })
145 await packageManagerInstall(
146 environment,
147 options.targetDir,
148 options.packageManager,
149 )
150 environment.finishStep('install-dependencies', 'Installed dependencies')
151 s.stop(`Installed dependencies`)
152 } else {
153 s.start(`Skipping dependency installation...`)
154 environment.startStep({
155 id: 'skip-dependencies',
156 type: 'info',
157 message: `Skipping dependency installation...`,
158 })
159 environment.finishStep('skip-dependencies', 'Dependency installation skipped')
160 s.stop(`Dependency installation skipped`)
161 }
162​
163 // Run any post-init special steps for the new add-ons
164 const postInitSpecialSteps = new Set<string>([])
165 for (const addOn of options.chosenAddOns) {
166 for (const step of addOn.postInitSpecialSteps || []) {
167 postInitSpecialSteps.add(step)
168 }
169 }
170 if (postInitSpecialSteps.size) {
171 await runSpecialSteps(
172 environment,
173 options,
174 Array.from(postInitSpecialSteps),
175 )
176 }
177​
178 for (const phase of ['setup', 'add-on', 'example']) {
179 for (const addOn of options.chosenAddOns.filter(
180 (addOn) =>
181 addOn.phase === phase && addOn.command && addOn.command.command,
182 )) {
183 s.start(`Running commands for ${addOn.name}...`)
184 const cmd = formatCommand({
185 command: addOn.command!.command,
186 args: addOn.command!.args || [],
187 })
188 environment.startStep({
189 id: 'run-commands',
190 type: 'command',
191 message: cmd,
192 })
193 await environment.execute(
194 addOn.command!.command,
195 addOn.command!.args || [],
196 options.targetDir,
197 { inherit: true },
198 )
199 environment.finishStep('run-commands', 'Setup commands complete')
200 s.stop(`${addOn.name} commands complete`)
201 }
202 }
203​
204 // Adding starter
205 if (
206 options.starter &&
207 options.starter.command &&
208 options.starter.command.command
209 ) {
210 s.start(`Setting up starter ${options.starter.name}...`)
211 const cmd = formatCommand({
212 command: options.starter.command.command,
213 args: options.starter.command.args || [],
214 })
215 environment.startStep({
216 id: 'run-starter-command',
217 type: 'command',
218 message: cmd,
219 })
220​
221 await environment.execute(
222 options.starter.command.command,
223 options.starter.command.args || [],
224 options.targetDir,
225 { inherit: true },
226 )
227​
228 environment.finishStep('run-starter-command', 'Starter command complete')
229 s.stop(`${options.starter.name} commands complete`)
230 }
231​
232 await installShadcnComponents(environment, options.targetDir, options)
234​
235function report(environment: Environment, options: Options) {
236 const warnings: Array<string> = []
237 for (const addOn of options.chosenAddOns) {
238 if (addOn.warning) {
239 warnings.push(addOn.warning)
240 }
241 }
242​
243 if (warnings.length > 0) {
244 environment.warn('Warnings', warnings.join('\n'))
245 }
246​
247 // Format errors
248 let errorStatement = ''
249 if (environment.getErrors().length) {
250 errorStatement = `
251​
252Errors were encountered during the creation of your app:
253​
254${environment.getErrors().join('\n')}`
255 }
256​
257 // Check if we created in current directory (user specified ".")
258 const isCurrentDirectory =
259 resolve(options.targetDir) === resolve(process.cwd())
260 const locationMessage = isCurrentDirectory
261 ? `Your ${environment.appName} app is ready.`
262 : `Your ${environment.appName} app is ready in '${basename(options.targetDir)}'.`
263 const cdInstruction = isCurrentDirectory
264 ? ''
265 : `% cd ${options.projectName}
267​
268 // Use the force luke! :)
269 environment.outro(
270 `${locationMessage}
271​
272Use the following commands to start your app:
273${cdInstruction}% ${formatCommand(
274 getPackageManagerScriptCommand(options.packageManager, ['dev']),
275 )}
276​
277Please read the README.md file for information on testing, styling, adding routes, etc.${errorStatement}`,
278 )
280​
281export async function createApp(environment: Environment, options: Options) {
282 environment.startRun()
283 await writeFiles(environment, options)
284 await runCommandsAndInstallDependencies(environment, options)
285 environment.finishRun()
286​
287 report(environment, options)