Open History to see the last commit
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 translateExecuteCommand,
10} from './package-manager.js'
11import { createPackageJSON } from './package-json.js'
12import { resolvePackageJSONLatest } from './npm-resolver.js'
13import { createTemplateFile } from './template-file.js'
14import { installShadcnComponents } from './integrations/shadcn.js'
15import { setupGit } from './integrations/git.js'
16import { runSpecialSteps } from './special-steps/index.js'
17
18import type { Environment, FileBundleHandler, Options } from './types.js'
19
20function isDemoFilePath(path?: string) {
21 if (!path) return false
22 const normalized = path.replace(/\\/g, '/')
23
24 if (
25 normalized.includes('/routes/demo/') ||
26 normalized.includes('/routes/example/')
27 ) {
28 return true
29 }
30
31 const filename = normalized.split('/').pop() || ''
32 return (
33 filename.startsWith('demo.') ||
34 filename.startsWith('demo-') ||
35 filename.startsWith('example.') ||
36 filename.startsWith('example-')
37 )
38}
39
40function stripExamplesFromOptions(options: Options): Options {
41 if (options.includeExamples !== false) {
42 return options
43 }
44
45 const chosenAddOns = options.chosenAddOns
46 .filter((addOn) => addOn.type !== 'example')
47 .map((addOn) => {
48 const filteredRoutes = (addOn.routes || []).filter(
49 (route) =>
50 !isDemoFilePath(route.path) &&
51 !(route.url && route.url.startsWith('/demo')),
52 )
54 const filteredIntegrations = (addOn.integrations || []).filter(
55 (integration) => !isDemoFilePath(integration.path)
56 )
57
58 return {
59 ...addOn,
60 routes: filteredRoutes,
61 integrations: filteredIntegrations,
62 getFiles: async () => {
63 const files = await addOn.getFiles()
64 return files.filter((file) => !isDemoFilePath(file))
65 },
66 getDeletedFiles: async () => {
67 const deletedFiles = await addOn.getDeletedFiles()
68 return deletedFiles.filter((file) => !isDemoFilePath(file))
69 },
70 }
71 })
72
73 return {
74 ...options,
75 chosenAddOns,
76 }
77}
78
79async function writeFiles(environment: Environment, options: Options) {
80 const templateFileFromContent = createTemplateFile(environment, options)
81
82 async function writeFileBundle(bundle: FileBundleHandler) {
83 const files = await bundle.getFiles()
84
85 for (const file of files) {
86 const contents = await bundle.getFileContents(file)
87
88 const isBinaryFile = isBase64(contents)
89 if (isBinaryFile) {
90 await environment.writeFileBase64(
91 resolve(options.targetDir, file),
92 contents,
93 )
94 } else {
95 await templateFileFromContent(file, contents)
96 }
97 }
98
99 const deletedFiles = await bundle.getDeletedFiles()
100 for (const file of deletedFiles) {
101 await environment.deleteFile(resolve(options.targetDir, file))
102 }
103 }
104
105 environment.startStep({
106 id: 'write-framework-files',
107 type: 'file',
108 message: 'Writing framework files...',
109 })
110 await writeFileBundle(options.framework)
111 environment.finishStep('write-framework-files', 'Framework files written')
112
113 let wroteAddonFiles = false
114 for (const type of ['add-on', 'example', 'toolchain', 'deployment']) {
115 for (const phase of ['setup', 'add-on', 'example']) {
116 for (const addOn of options.chosenAddOns.filter(
117 (addOn) => addOn.phase === phase && addOn.type === type,
118 )) {
119 environment.startStep({
120 id: 'write-addon-files',
121 type: 'file',
122 message: `Writing ${addOn.name} files...`,
123 })
124 await writeFileBundle(addOn)
125 wroteAddonFiles = true
126 }
127 }
128 }
129 if (wroteAddonFiles) {
130 environment.finishStep('write-addon-files', 'Add-on files written')
131 }
132
133 if (options.starter) {
134 environment.startStep({
135 id: 'write-starter-files',
136 type: 'file',
137 message: 'Writing starter files...',
138 })
139 await writeFileBundle(options.starter)
140 environment.finishStep('write-starter-files', 'Starter files written')
141 }
142
143 environment.startStep({
144 id: 'write-package-json',
145 type: 'file',
146 message: 'Writing package.json...',
147 })
148 const packageJSON = await resolvePackageJSONLatest(createPackageJSON(options))
149 await environment.writeFile(
150 resolve(options.targetDir, './package.json'),
151 JSON.stringify(packageJSON, null, 2),
152 )
153 environment.finishStep('write-package-json', 'Package.json written')
154
155 environment.startStep({
156 id: 'write-config-file',
157 type: 'file',
158 message: 'Writing config file...',
159 })
160 await writeConfigFileToEnvironment(environment, options)
161 environment.finishStep('write-config-file', 'Config file written')
162}
163
164async function runCommandsAndInstallDependencies(
165 environment: Environment,
166 options: Options,
167) {
168 const s = environment.spinner()
169
170 // Setup git
171 if (options.git) {
172 s.start(`Initializing git repository...`)
173 environment.startStep({
174 id: 'initialize-git-repository',
175 type: 'command',
176 message: 'Initializing git repository...',
177 })
178
179 await setupGit(environment, options.targetDir)
180
181 environment.finishStep(
182 'initialize-git-repository',
183 'Initialized git repository',
184 )
185 s.stop(`Initialized git repository`)
186 }
187
188 // Run any special steps for the new add-ons
189 const specialSteps = new Set<string>([])
190 for (const addOn of options.chosenAddOns) {
191 for (const step of addOn.createSpecialSteps || []) {
192 specialSteps.add(step)
193 }
194 }
195 if (specialSteps.size) {
196 await runSpecialSteps(environment, options, Array.from(specialSteps))
197 }
198
199 // Install dependencies
200 if (options.install !== false) {
201 s.start(`Installing dependencies via ${options.packageManager}...`)
202 environment.startStep({
203 id: 'install-dependencies',
204 type: 'package-manager',
205 message: `Installing dependencies via ${options.packageManager}...`,
206 })
207 await packageManagerInstall(
208 environment,
209 options.targetDir,
210 options.packageManager,
211 )
212 environment.finishStep('install-dependencies', 'Installed dependencies')
213 s.stop(`Installed dependencies`)
214 } else {
215 s.start(`Skipping dependency installation...`)
216 environment.startStep({
217 id: 'skip-dependencies',
218 type: 'info',
219 message: `Skipping dependency installation...`,
220 })
221 environment.finishStep('skip-dependencies', 'Dependency installation skipped')
222 s.stop(`Dependency installation skipped`)
223 }
224
225 // Run any post-init special steps for the new add-ons
226 const postInitSpecialSteps = new Set<string>([])
227 for (const addOn of options.chosenAddOns) {
228 for (const step of addOn.postInitSpecialSteps || []) {
229 postInitSpecialSteps.add(step)
230 }
231 }
232 if (postInitSpecialSteps.size) {
233 await runSpecialSteps(
234 environment,
235 options,
236 Array.from(postInitSpecialSteps),
237 )
238 }
239
240 for (const phase of ['setup', 'add-on', 'example']) {
241 for (const addOn of options.chosenAddOns.filter(
242 (addOn) =>
243 addOn.phase === phase && addOn.command && addOn.command.command,
244 )) {
245 s.start(`Running commands for ${addOn.name}...`)
246 const translated = translateExecuteCommand(options.packageManager, {
247 command: addOn.command!.command,
248 args: addOn.command!.args || [],
249 })
250 const cmd = formatCommand(translated)
251 environment.startStep({
252 id: 'run-commands',
253 type: 'command',
254 message: cmd,
255 })
256 await environment.execute(
257 translated.command,
258 translated.args,
259 options.targetDir,
260 { inherit: true },
261 )
262 environment.finishStep('run-commands', 'Setup commands complete')
263 s.stop(`${addOn.name} commands complete`)
264 }
265 }
266
267 // Adding starter
268 if (
269 options.starter &&
270 options.starter.command &&
271 options.starter.command.command
272 ) {
273 s.start(`Setting up starter ${options.starter.name}...`)
274 const starterTranslated = translateExecuteCommand(options.packageManager, {
275 command: options.starter.command.command,
276 args: options.starter.command.args || [],
277 })
278 const cmd = formatCommand(starterTranslated)
279 environment.startStep({
280 id: 'run-starter-command',
281 type: 'command',
282 message: cmd,
283 })
284
285 await environment.execute(
286 starterTranslated.command,
287 starterTranslated.args,
288 options.targetDir,
289 { inherit: true },
290 )
291
292 environment.finishStep('run-starter-command', 'Starter command complete')
293 s.stop(`${options.starter.name} commands complete`)
294 }
295
296 await installShadcnComponents(environment, options.targetDir, options)
297}
298
299async function seedEnvValues(environment: Environment, options: Options) {
300 const envVarValues = options.envVarValues || {}
301 const entries = Object.entries(envVarValues)
302 if (entries.length === 0) return
303
304 const envLocalPath = resolve(options.targetDir, '.env.local')
305 if (!environment.exists(envLocalPath)) {
306 return
307 }
308
309 let envContents = await environment.readFile(envLocalPath)
310 for (const [key, value] of entries) {
311 const escapedValue = value.replace(/\n/g, '\\n')
312 const nextLine = `${key}=${escapedValue}`
313 const pattern = new RegExp(`^${key}=.*$`, 'm')
314
315 if (pattern.test(envContents)) {
316 envContents = envContents.replace(pattern, nextLine)
317 } else {
318 envContents += `${envContents.endsWith('\n') ? '' : '\n'}${nextLine}\n`
319 }
320 }
321
322 await environment.writeFile(envLocalPath, envContents)
323}
324
325function report(environment: Environment, options: Options) {
326 const warnings: Array<string> = []
327 for (const addOn of options.chosenAddOns) {
328 if (addOn.warning) {
329 warnings.push(addOn.warning)
330 }
331 }
332
333 if (warnings.length > 0) {
334 environment.warn('Warnings', warnings.join('\n'))
335 }
336
337 // Format errors
338 let errorStatement = ''
339 if (environment.getErrors().length) {
340 errorStatement = `
341
342Errors were encountered during the creation of your app:
343
344${environment.getErrors().join('\n')}`
345 }
346
347 // Check if we created in current directory (user specified ".")
348 const isCurrentDirectory =
349 resolve(options.targetDir) === resolve(process.cwd())
350 const locationMessage = isCurrentDirectory
351 ? `Your ${environment.appName} app is ready.`
352 : `Your ${environment.appName} app is ready in '${basename(options.targetDir)}'.`
353 const cdInstruction = isCurrentDirectory
354 ? ''
355 : `% cd ${options.projectName}
356`
357
358 // Use the force luke! :)
359 environment.outro(
360 `${locationMessage}
361
362Use the following commands to start your app:
363${cdInstruction}% ${formatCommand(
364 getPackageManagerScriptCommand(options.packageManager, ['dev']),
365 )}
366
367Please read the README.md file for information on testing, styling, adding routes, etc.${errorStatement}`,
368 )
369}
370
371export async function createApp(environment: Environment, options: Options) {
372 const effectiveOptions = stripExamplesFromOptions(options)
373
374 environment.startRun()
375 await writeFiles(environment, effectiveOptions)
376 await seedEnvValues(environment, effectiveOptions)
377 await runCommandsAndInstallDependencies(environment, effectiveOptions)
378 environment.finishRun()
379
380 report(environment, effectiveOptions)
381}