@stacksjs/buddy 0.66.0 → 0.67.0

package/src/commands/create.ts

@@ -1,143 +0,0 @@
-import type { CLI, CreateOptions } from '@stacksjs/types'
-import process from 'node:process'
-import { runAction } from '@stacksjs/actions'
-import { bold, cyan, dim, intro, log, runCommand } from '@stacksjs/cli'
-import { Action } from '@stacksjs/enums'
-import { resolve } from '@stacksjs/path'
-import { isFolder } from '@stacksjs/storage'
-import { ExitCode } from '@stacksjs/types'
-import { useOnline } from '@stacksjs/utils'
-
-export function create(buddy: CLI): void {
-  const descriptions = {
-    name: 'The name of the project',
-    command: 'Create a new Stacks project',
-    ui: 'Are you building a UI?',
-    components: 'Are you building UI components?',
-    webComponents: 'Automagically built optimized custom elements/web components?',
-    vue: 'Automagically built a Vue component library?',
-    views: 'How about views?',
-    functions: 'Are you developing functions/composables?',
-    api: 'Are you building an API?',
-    database: 'Do you need a database?',
-    notifications: 'Do you need notifications? e.g. email, SMS, push or chat notifications',
-    cache: 'Do you need caching?',
-    email: 'Do you need email?',
-    project: 'Target a specific project',
-    verbose: 'Enable verbose output',
-  }
-
-  buddy
-    .command('new [name]', descriptions.command)
-    .alias('create [name]')
-    .option('-n, --name [name]', descriptions.name, { default: false })
-    .option('-u, --ui', descriptions.ui, { default: true }) // if no, disregard remainder of questions wrt UI
-    .option('-c, --components', descriptions.components, { default: true }) // if no, -v and -w would be false
-    .option('-w, --web-components', descriptions.webComponents, { default: true })
-    .option('-v, --vue', descriptions.vue, { default: true })
-    .option('-p, --views', descriptions.views, { default: true }) // i.e. `buddy dev`
-    .option('-f, --functions', descriptions.functions, { default: true }) // if no, API would be false
-    .option('-a, --api', descriptions.api, { default: true }) // APIs need an HTTP server & assumes functions is true
-    .option('-d, --database', descriptions.database, { default: true })
-    .option('-ca, --cache', descriptions.cache, { default: false })
-    .option('-e, --email', descriptions.email, { default: false })
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    // .option('--auth', 'Scaffold an authentication?', { default: true })
-    .action(async (name, options: CreateOptions) => {
-      log.debug('Running `buddy new <name>` ...', options)
-
-      const startTime = await intro('stacks new')
-
-      name = name ?? options.name
-      const path = resolve(process.cwd(), name)
-
-      isFolderCheck(path)
-      onlineCheck()
-
-      const result = await download(name, path, options)
-
-      if (result.isErr()) {
-        log.error(result.error)
-        process.exit(ExitCode.FatalError)
-      }
-
-      await ensureEnv(path, options)
-      await install(path, options)
-
-      if (startTime) {
-        const time = performance.now() - startTime
-        log.success(dim(`[${time.toFixed(2)}ms] Completed`))
-      }
-
-      log.info(bold('Welcome to the Stacks Framework! ⚛️'))
-      log.info('To learn more, visit https://stacksjs.org')
-
-      process.exit(ExitCode.Success)
-    })
-
-  buddy.on('new:*', () => {
-    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
-    process.exit(1)
-  })
-}
-
-function isFolderCheck(path: string) {
-  if (isFolder(path)) {
-    log.error(`Path ${path} already exists`)
-    process.exit(ExitCode.FatalError)
-  }
-}
-
-function onlineCheck() {
-  const online = useOnline()
-  if (!online) {
-    log.info('It appears you are disconnected from the internet.')
-    log.info('The Stacks setup requires a brief internet connection for setup.')
-    log.info('For instance, it installs your dependencies from.')
-    process.exit(ExitCode.FatalError)
-  }
-}
-
-async function download(name: string, path: string, options: CreateOptions) {
-  log.info('Setting up your stack.')
-  const result = await runCommand(`bunx --bun giget stacks ${name}`, options)
-  log.success(`Successfully scaffolded your project at ${cyan(path)}`)
-
-  return result
-}
-
-async function ensureEnv(path: string, options: CreateOptions) {
-  log.info('Ensuring your environment is ready...')
-  await runCommand('pkgx --update ', { ...options, cwd: path })
-  log.success('Environment is ready')
-}
-
-async function install(path: string, options: CreateOptions) {
-  log.info('Installing & setting up Stacks')
-  let result = await runCommand('bun install', { ...options, cwd: path })
-
-  if (result?.isErr()) {
-    log.error(result.error)
-    process.exit()
-  }
-
-  result = await runCommand('cp .env.example .env', { ...options, cwd: path })
-
-  if (result?.isErr()) {
-    log.error(result.error)
-    process.exit(ExitCode.FatalError)
-  }
-
-  await runAction(Action.KeyGenerate, { ...options, cwd: path })
-
-  // TODO: we should ask quite a few questions here, similar how we do in `buddy new my-project`, so we can generate a custom pkgx.yaml file
-
-  result = await runCommand('git init', { ...options, cwd: path }) // do we need this? or does giget do this already?
-  if (result.isErr()) {
-    log.error(result.error)
-    process.exit(ExitCode.FatalError)
-  }
-
-  log.success('Installed & set-up 🚀')
-}

package/src/commands/deploy.ts

@@ -1,194 +0,0 @@
-import type { CLI, DeployOptions } from '@stacksjs/types'
-import { $ } from 'bun'
-import process from 'node:process'
-import { runAction } from '@stacksjs/actions'
-import { intro, italic, log, outro, prompts, runCommand } from '@stacksjs/cli'
-import { app } from '@stacksjs/config'
-import { addDomain, hasUserDomainBeenAddedToCloud } from '@stacksjs/dns'
-import { Action } from '@stacksjs/enums'
-import { path as p } from '@stacksjs/path'
-import { ExitCode } from '@stacksjs/types'
-
-export function deploy(buddy: CLI): void {
-  const descriptions = {
-    deploy: 'Deploy your project',
-    project: 'Target a specific project',
-    production: 'Deploy to production',
-    development: 'Deploy to development',
-    staging: 'Deploy to staging',
-    yes: 'Confirm all prompts by default',
-    domain: 'Specify a domain to deploy to',
-    verbose: 'Enable verbose output',
-  }
-
-  buddy
-    .command('deploy [env]', descriptions.deploy)
-    .option('--domain', descriptions.domain, { default: undefined })
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--prod', descriptions.production, { default: true })
-    .option('--dev', descriptions.development, { default: false })
-    .option('--yes', descriptions.yes, { default: false })
-    .option('--staging', descriptions.staging, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (env: string | undefined, options: DeployOptions) => {
-      log.debug('Running `buddy deploy` ...', options)
-
-      const startTime = await intro('buddy deploy')
-      const domain = options.domain || app.url
-
-      if ((options.prod || env === 'production' || env === 'prod') && !options.yes)
-        await confirmProductionDeployment()
-
-      if (!domain) {
-        log.info('No domain found in your .env or ./config/app.ts')
-        log.info('Please ensure your domain is properly configured.')
-        log.info('For more info, check out the docs or join our Discord.')
-        process.exit(ExitCode.FatalError)
-      }
-
-      log.info(`Deploying to ${italic(domain)}`)
-
-      await checkIfAwsIsConfigured()
-      await checkIfAwsIsBootstrapped()
-
-      options.domain = await configureDomain(domain, options, startTime)
-
-      const result = await runAction(Action.Deploy, options)
-
-      if (result.isErr()) {
-        await outro(
-          'While running the `buddy deploy`, there was an issue',
-          { startTime, useSeconds: true },
-          result.error,
-        )
-        process.exit(ExitCode.FatalError)
-      }
-
-      await outro('Project deployed.', { startTime, useSeconds: true })
-    })
-
-  buddy.on('deploy:*', () => {
-    log.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
-    process.exit(1)
-  })
-}
-
-async function confirmProductionDeployment() {
-  const { confirmed } = await prompts({
-    type: 'confirm',
-    name: 'confirmed',
-    message: 'Are you sure you want to deploy to production?',
-  })
-
-  if (!confirmed) {
-    log.info('Aborting deployment...')
-    process.exit(ExitCode.InvalidArgument)
-  }
-}
-
-async function configureDomain(domain: string, options: DeployOptions, startTime: number) {
-  log.debug('Configuring domain...', domain)
-  if (!domain) {
-    log.info('We could not identify a domain to deploy to.')
-    log.warn('Please set your .env or ./config/app.ts properly.')
-    log.info('Alternatively, specify a domain to deploy via the `--domain` flag.')
-    console.log('')
-    log.info('   ➡️  Example: `buddy deploy --domain example.com`')
-    console.log('')
-    process.exit(ExitCode.FatalError)
-  }
-
-  // TODO: we can improve this check at some point, otherwise domains that legitimately include the word localhost will fail
-  // TODO: add check for whether the local APP_ENV is getting deployed, if so, ask if the user meant to deploy `dev`
-  if (domain.includes('localhost')) {
-    log.info('You are deploying to a local environment.')
-    log.warn(
-      'Please set your .env or ./config/app.ts properly. The domain we are deploying cannot be a `localhost` domain.',
-    )
-    log.info('Alternatively, specify a domain to deploy via the `--domain` flag.')
-    console.log('')
-    log.info('   ➡️  Example: `buddy deploy --domain example.com`')
-    console.log('')
-    process.exit(ExitCode.FatalError)
-  }
-
-  if (await hasUserDomainBeenAddedToCloud(domain)) {
-    log.info('Domain is properly configured')
-    log.info('Your cloud is deploying...')
-
-    log.info(`${italic('This may take a while...')}`)
-
-    return domain
-  }
-
-  // if the domain hasn't been added to the user's (AWS) cloud, we will add it for them
-  // and then exit the process with prompts for the user to update their nameservers
-  console.log('')
-  log.info(`  👋  It appears to be your first ${italic(domain)} deployment.`)
-  console.log('')
-  log.info(italic('Let’s ensure it is all connected properly.'))
-  log.info(italic('One moment...'))
-  console.log('')
-
-  const result = await addDomain({
-    ...options,
-    deploy: true,
-    startTime,
-  })
-
-  if (result.isErr()) {
-    await outro('While running the `buddy deploy`, there was an issue', { startTime, useSeconds: true }, result.error)
-    process.exit(ExitCode.FatalError)
-  }
-
-  await outro('Added your domain.', { startTime, useSeconds: true })
-  process.exit(ExitCode.Success)
-}
-
-async function checkIfAwsIsConfigured() {
-  log.info('Ensuring AWS is configured...')
-  const result = await runCommand('buddy configure:aws', {
-    silent: true,
-  })
-
-  if (result.isErr()) {
-    log.error('AWS is not configured properly.', {
-      shouldExit: false,
-    })
-    log.error('Please run `buddy configure:aws` to set up your AWS credentials.')
-  }
-
-  log.success('AWS is configured')
-}
-
-async function checkIfAwsIsBootstrapped() {
-  try {
-    log.info('Ensuring AWS is bootstrapped...')
-    // const toolkitName = 'stacks-toolkit'
-    await runCommand('aws cloudformation describe-stacks --stack-name stacks-toolkit', { silent: true })
-    // await $`aws cloudformation describe-stacks --stack-name stacks-toolkit`.quiet()
-    log.success('AWS is bootstrapped')
-
-    return true
-  }
-  catch (err: any) {
-    log.debug(`Not yet bootstrapped. Failed with code ${err.exitCode}`)
-    log.debug(err.stdout.toString())
-    log.debug(err.stderr.toString())
-
-    log.info('AWS is not bootstrapped yet')
-    log.info('Bootstrapping. This may take a few moments...')
-
-    try {
-      $.cwd(p.frameworkCloudPath())
-      const result = await $`bun run bootstrap`
-      console.log(result)
-      return true
-    }
-    catch (error) {
-      log.error('Failed to bootstrap AWS')
-      console.error(error)
-      process.exit(ExitCode.FatalError)
-    }
-  }
-}

package/src/commands/dev.ts

@@ -1,292 +0,0 @@
-import type { CLI, DevOptions } from '@stacksjs/types'
-import process from 'node:process'
-import {
-  runAction,
-  runApiDevServer,
-  runComponentsDevServer,
-  runDashboardDevServer,
-  runDesktopDevServer,
-  runDocsDevServer,
-  runFrontendDevServer,
-  runSystemTrayDevServer,
-} from '@stacksjs/actions'
-import { intro, log, outro, prompts, runCommand } from '@stacksjs/cli'
-import { Action } from '@stacksjs/enums'
-import { libsPath } from '@stacksjs/path'
-import { ExitCode } from '@stacksjs/types'
-
-export function dev(buddy: CLI): void {
-  const descriptions = {
-    dev: 'Start development server',
-    frontend: 'Start the frontend development server',
-    components: 'Start the Components development server',
-    desktop: 'Start the Desktop App development server',
-    dashboard: 'Start the Dashboard development server',
-    api: 'Start the local API development server',
-    email: 'Start the Email development server',
-    docs: 'Start the Documentation development server',
-    systemTray: 'Start the System Tray development server',
-    interactive: 'Get asked which development server to start',
-    select: 'Which development server are you trying to start?',
-    withLocalhost: 'Include the localhost URL in the output',
-    project: 'Target a specific project',
-    verbose: 'Enable verbose output',
-  }
-
-  buddy
-    .command('dev [server]', descriptions.dev) // server is optional because options can be used
-    .option('-f, --frontend', descriptions.frontend)
-    .option('-a, --api', descriptions.api)
-    .option('-e, --email', descriptions.email)
-    .option('-c, --components', descriptions.components)
-    .option('-d, --dashboard', descriptions.dashboard)
-    .option('-t, --desktop', descriptions.desktop)
-    .option('-d, --docs', descriptions.docs)
-    .option('-t, --system-tray', descriptions.systemTray)
-    .option('-i, --interactive', descriptions.interactive, { default: false })
-    .option('-l, --with-localhost', descriptions.withLocalhost, {
-      default: false,
-    })
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (server: string | undefined, options: DevOptions) => {
-      log.debug('Running `buddy dev [server]` ...', options)
-
-      const perf = await intro('buddy dev')
-
-      // log.info('Ensuring web server/s running...')
-
-      // // check if port 443 is open
-      // const result = await runCommand('lsof -i :443', { silent: true })
-
-      // if (result.isErr())
-      //   log.warn('While checking if port 443 is open, we noticed it may be in use')
-
-      switch (server) {
-        case 'frontend':
-          await runFrontendDevServer(options)
-          break
-        case 'api':
-          await runApiDevServer(options)
-          break
-        case 'components':
-          await runComponentsDevServer(options)
-          break
-        case 'dashboard':
-          await runDashboardDevServer(options)
-          break
-        case 'desktop':
-          await runDesktopDevServer(options)
-          break
-        case 'system-tray':
-          await runSystemTrayDevServer(options)
-          break
-        // case 'email':
-        //   await runEmailDevServer(options)
-        //   break
-        case 'docs':
-          await runDocsDevServer(options)
-          break
-        default:
-      }
-
-      if (wantsInteractive(options)) {
-        const answer = await prompts({
-          type: 'select',
-          name: 'value',
-          message: descriptions.select,
-          choices: [
-            { value: 'all', title: 'All' },
-            { value: 'frontend', title: 'Frontend' },
-            { value: 'api', title: 'Backend' },
-            { value: 'dashboard', title: 'Dashboard' },
-            { value: 'desktop', title: 'Desktop' },
-            { value: 'email', title: 'Email' },
-            { value: 'components', title: 'Components' },
-            { value: 'docs', title: 'Documentation' },
-          ],
-        })
-
-        const selectedValue: string = answer.value
-
-        if (selectedValue === 'components') {
-          await runComponentsDevServer(options)
-        }
-        else if (selectedValue === 'api') {
-          await runApiDevServer(options)
-        }
-        else if (selectedValue === 'dashboard') {
-          await runDashboardDevServer(options)
-        }
-        // else if (selectedValue === 'email')
-        //   await runEmailDevServer(options)
-        else if (selectedValue === 'docs') {
-          await runDocsDevServer(options)
-        }
-        else {
-          log.error('Invalid option during interactive mode')
-          process.exit(ExitCode.InvalidArgument)
-        }
-      }
-      else {
-        if (options.components)
-          await runComponentsDevServer(options)
-        if (options.docs)
-          await runDocsDevServer(options)
-        else if (options.api)
-          await runApiDevServer(options)
-        // else if (options.email)
-        //   await runEmailDevServer(options)
-      }
-
-      await startDevelopmentServer(options)
-
-      outro('Exited', { startTime: perf, useSeconds: true })
-      process.exit(ExitCode.Success)
-    })
-
-  buddy
-    .command('dev:components', descriptions.components)
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:components` ...', options)
-
-      const perf = await intro('buddy dev:components')
-      const result = await runCommand('bun run dev', {
-        cwd: libsPath('components/vue'),
-        // silent: !options.verbose,
-      })
-
-      if (options.verbose)
-        log.info('buddy dev:components result', result)
-
-      if (result.isErr()) {
-        await outro(
-          'While running the dev:components command, there was an issue',
-          { startTime: perf, useSeconds: true },
-          result.error,
-        )
-        process.exit()
-      }
-
-      console.log('')
-      await outro('Exited', { startTime: perf, useSeconds: true })
-      process.exit(ExitCode.Success)
-    })
-
-  buddy
-    .command('dev:docs', descriptions.docs)
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:docs` ...', options)
-
-      const perf = await intro('buddy dev:docs')
-      const result = await runAction(Action.DevDocs, options)
-
-      if (result.isErr()) {
-        await outro(
-          'While running the dev:docs command, there was an issue',
-          { startTime: perf, useSeconds: true },
-          result.error,
-        )
-        process.exit()
-      }
-
-      console.log('')
-      await outro('Exited', { startTime: perf, useSeconds: true })
-      process.exit(ExitCode.Success)
-    })
-
-  buddy
-    .command('dev:desktop', descriptions.desktop)
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:desktop` ...', options)
-
-      const perf = await intro('buddy dev:desktop')
-      const result = await runAction(Action.DevDesktop, options)
-
-      if (result.isErr()) {
-        await outro(
-          'While running the dev:desktop command, there was an issue',
-          { startTime: perf, useSeconds: true },
-          result.error,
-        )
-        process.exit()
-      }
-
-      console.log('')
-      await outro('Exited', { startTime: perf, useSeconds: true })
-      process.exit(ExitCode.Success)
-    })
-
-  buddy
-    .command('dev:api', descriptions.api)
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:api` ...', options)
-
-      await runApiDevServer(options)
-    })
-
-  // buddy
-  //   .command('dev:functions', descriptions.api)
-  //   .option('-p, --project [project]', descriptions.project, { default: false })//
-  //   .option('--verbose', descriptions.verbose, { default: false })
-  //   .action(async (options: DevOptions) => {
-  //     await runFunctionsDevServer(options)
-  //   })
-
-  buddy
-    .command('dev:frontend', descriptions.frontend)
-    .alias('dev:pages')
-    .alias('dev:views')
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:frontend` ...', options)
-      await runFrontendDevServer(options)
-    })
-
-  buddy
-    .command('dev:dashboard', descriptions.dashboard)
-    .alias('dev:admin')
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:dashboard` ...', options)
-      await runDashboardDevServer(options)
-    })
-
-  buddy
-    .command('dev:system-tray', descriptions.systemTray)
-    .alias('dev:tray')
-    .option('-p, --project [project]', descriptions.project, { default: false })
-    .option('--verbose', descriptions.verbose, { default: false })
-    .action(async (options: DevOptions) => {
-      log.debug('Running `buddy dev:system-tray` ...', options)
-      await runSystemTrayDevServer(options)
-    })
-
-  buddy.on('dev:*', () => {
-    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
-    process.exit(1)
-  })
-}
-
-export async function startDevelopmentServer(options: DevOptions): Promise<void> {
-  const result = await runAction(Action.Dev, options)
-
-  if (result.isErr()) {
-    log.error('While running the dev command, there was an issue', result.error)
-    process.exit(ExitCode.InvalidArgument)
-  }
-}
-
-function wantsInteractive(options: DevOptions) {
-  return options.interactive
-}