Open History to see the last commit
1import { basename, resolve } from 'node:path'
2
3import { CONFIG_FILE } from './constants.js'
4import { finalizeAddOns } from './add-ons.js'
5import { getFrameworkById } from './frameworks.js'
6import { createMemoryEnvironment } from './environment.js'
7import { createApp } from './create-app.js'
8import {
9 readConfigFileFromEnvironment,
10 writeConfigFileToEnvironment,
11} from './config-file.js'
12import { formatCommand } from './utils.js'
13import { packageManagerInstall } from './package-manager.js'
14import {
15 isBase64,
16 recursivelyGatherFilesFromEnvironment,
17} from './file-helpers.js'
18import { mergePackageJSON } from './package-json.js'
19import { runSpecialSteps } from './special-steps/index.js'
20import { loadStarter } from './custom-add-ons/starter.js'
21
22import type { Environment, Options } from './types.js'
23import type { PersistedOptions } from './config-file.js'
24
25export async function hasPendingGitChanges(
26 environment: Environment,
27 cwd: string,
28) {
29 const { stdout } = await environment.execute(
30 'git',
31 ['status', '--porcelain'],
32 cwd,
33 )
34 return stdout.length > 0
35}
36
37async function createOptions(
38 json: PersistedOptions,
39 addOns: Array<string>,
40 targetDir: string,
41): Promise<Options> {
42 const framework = getFrameworkById(json.framework)
43
44 const starter = json.starter ? await loadStarter(json.starter) : undefined
45
46 return {
47 ...json,
48 framework,
49 tailwind: true,
50 addOns: true,
51 chosenAddOns: await finalizeAddOns(framework!, json.mode!, [
52 ...json.chosenAddOns,
53 ...addOns,
54 ]),
55 targetDir,
56 starter,
57 } as Options
58}
59
60async function runCreateApp(options: Required<Options>) {
61 const { environment, output } = createMemoryEnvironment(options.targetDir)
62 await createApp(environment, options)
63 return output
64}
65
66export async function getCurrentConfiguration(
67 environment: Environment,
68 cwd: string,
69) {
70 const persistedOptions = await readConfigFileFromEnvironment(environment, cwd)
71 if (!persistedOptions) {
72 environment.error(
73 'There is no .cta.json file in your project.',
74 'This is probably because this was created with an older version of create-tsrouter-app.',
75 )
76 return undefined
77 }
78
79 return persistedOptions
80}
81
82export async function writeFiles(
83 environment: Environment,
84 cwd: string,
85 output: {
86 files: Record<string, string>
87 deletedFiles: Array<string>
88 },
89 forced: boolean,
90) {
91 const currentFiles = await recursivelyGatherFilesFromEnvironment(
92 environment,
93 cwd,
94 false,
95 )
96
97 const overwrittenFiles: Array<string> = []
98 const changedFiles: Array<string> = []
99 for (const file of Object.keys(output.files)) {
100 const relativeFile = file.replace(cwd, '')
101 if (currentFiles[relativeFile]) {
102 if (currentFiles[relativeFile] !== output.files[file]) {
103 overwrittenFiles.push(relativeFile)
104 }
105 } else {
106 changedFiles.push(relativeFile)
107 }
108 }
109
110 if (!forced && overwrittenFiles.length) {
111 environment.warn(
112 'The following will be overwritten',
113 [...overwrittenFiles, ...output.deletedFiles].join('\n'),
114 )
115 const shouldContinue = await environment.confirm('Do you want to continue?')
116 if (!shouldContinue) {
117 throw new Error('User cancelled')
118 }
119 }
120
121 for (const file of output.deletedFiles) {
122 if (environment.exists(resolve(cwd, file))) {
123 await environment.deleteFile(resolve(cwd, file))
124 }
125 }
126
127 environment.startStep({
128 id: 'write-files',
129 type: 'file',
130 message: 'Writing add-on files...',
131 })
132
133 for (const file of [...changedFiles, ...overwrittenFiles]) {
134 const fName = basename(file)
135 const contents = output.files[file]
136 if (fName === 'package.json') {
137 const currentJson = JSON.parse(
138 await environment.readFile(resolve(cwd, file)),
139 )
140 const newJSON = mergePackageJSON(currentJson, JSON.parse(contents))
141 environment.writeFile(
142 resolve(cwd, file),
143 JSON.stringify(newJSON, null, 2),
144 )
145 } else if (fName !== CONFIG_FILE) {
146 if (isBase64(contents)) {
147 await environment.writeFileBase64(resolve(cwd, file), contents)
148 } else {
149 await environment.writeFile(resolve(cwd, file), contents)
150 }
151 }
152 }
153
154 environment.finishStep('write-files', 'Add-on files written')
155}
156
157export async function runNewCommands(
158 environment: Environment,
159 originalOptions: PersistedOptions,
160 cwd: string,
161 output: {
162 commands: Array<{
163 command: string
164 args: Array<string>
165 }>
166 },
167) {
168 const originalOutput = await runCreateApp({
169 ...(await createOptions(originalOptions, [], cwd)),
170 } as Required<Options>)
171
172 const originalCommands = new Set(
173 originalOutput.commands.map((c) => [c.command, ...c.args].join(' ')),
174 )
175
176 for (const command of output.commands) {
177 const commandString = [command.command, ...command.args].join(' ')
178 if (!originalCommands.has(commandString)) {
179 environment.startStep({
180 id: 'run-commands',
181 type: 'command',
182 message: `Running ${formatCommand({ command: command.command, args: command.args })}...`,
183 })
184 await environment.execute(command.command, command.args, cwd, {
185 inherit: true,
186 })
187 environment.finishStep('run-commands', 'Setup commands complete')
188 }
189 }
190}
191
192export async function addToApp(
193 environment: Environment,
194 addOns: Array<string>,
195 cwd: string,
196 options?: {
197 forced?: boolean
198 },
199) {
200 const persistedOptions = await getCurrentConfiguration(environment, cwd)
201 if (!persistedOptions) {
202 return
203 }
204
205 if (!options?.forced && (await hasPendingGitChanges(environment, cwd))) {
206 environment.error(
207 'You have pending git changes.',
208 'Please commit or stash them before adding add-ons.',
209 )
210 return
211 }
212
213 environment.intro(`Adding ${addOns.join(', ')} to the project...`)
214 environment.startStep({
215 id: 'processing-new-app-setup',
216 type: 'file',
217 message: 'Processing new app setup...',
218 })
219
220 const newOptions = await createOptions(persistedOptions, addOns, cwd)
221
222 const output = await runCreateApp({
223 ...newOptions,
224 targetDir: cwd,
225 } as Required<Options>)
226
227 await writeFiles(environment, cwd, output, !!options?.forced)
228
229 environment.finishStep(
230 'processing-new-app-setup',
231 'Application files written',
232 )
233
234 // Run any special steps for the new add-ons
235
236 const specialSteps = new Set<string>([])
237 for (const addOn of newOptions.chosenAddOns) {
238 for (const step of addOn.addOnSpecialSteps || []) {
239 if (addOns.includes(addOn.id)) {
240 specialSteps.add(step)
241 }
242 }
243 }
244 if (specialSteps.size) {
245 await runSpecialSteps(environment, newOptions, Array.from(specialSteps))
246 }
247
248 // Install dependencies
249
250 environment.startStep({
251 id: 'install-dependencies',
252 type: 'package-manager',
253 message: `Installing dependencies via ${newOptions.packageManager}...`,
254 })
255 const s = environment.spinner()
256 s.start(`Installing dependencies via ${newOptions.packageManager}...`)
257 await packageManagerInstall(
258 environment,
259 newOptions.targetDir,
260 newOptions.packageManager,
261 )
262 s.stop(`Installed dependencies`)
263 environment.finishStep('install-dependencies', 'Dependencies installed')
264
265 // Run any post-init special steps for the new add-ons
266 const postInitSpecialSteps = new Set<string>([])
267 for (const addOn of newOptions.chosenAddOns) {
268 for (const step of addOn.postInitSpecialSteps || []) {
269 if (addOns.includes(addOn.id)) {
270 postInitSpecialSteps.add(step)
271 }
272 }
273 }
274 if (postInitSpecialSteps.size) {
275 await runSpecialSteps(
276 environment,
277 newOptions,
278 Array.from(postInitSpecialSteps),
279 )
280 }
281
282 // Handle new commands
283
284 await runNewCommands(environment, persistedOptions, cwd, output)
285
286 environment.startStep({
287 id: 'write-config-file',
288 type: 'file',
289 message: 'Writing config file...',
290 })
291 writeConfigFileToEnvironment(environment, newOptions)
292 environment.finishStep('write-config-file', 'Config file written')
293
294 environment.outro(`Add-ons ${addOns.join(', ')} added!`)
295}