@stacksjs/buddy 0.58.48 → 0.58.49

package/src/commands/migrate.ts

@@ -0,0 +1,58 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, MigrateOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+
+export function migrate(buddy: CLI) {
+  const descriptions = {
+    migrate: 'Migrates your database',
+    dns: 'Writes the DNS records for a domain to ./config/dns.ts',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('migrate', descriptions.migrate)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: MigrateOptions) => {
+      const perf = await intro('buddy migrate')
+      const result = await runAction(Action.Migrate, { ...options })
+
+      if (result.isErr()) {
+        await outro('While running the migrate command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      const APP_ENV = process.env.APP_ENV || 'local'
+
+      await outro(`Migrated your ${APP_ENV} database.`, { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('migrate:dns', descriptions.migrate)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: MigrateOptions) => {
+      const perf = await intro('buddy migrate')
+      const result = await runAction(Action.MigrateDns, { ...options })
+
+      if (result.isErr()) {
+        await outro('While running the migrate:dns command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      const APP_URL = process.env.APP_URL || 'undefined'
+
+      await outro(`Migrated your ${APP_URL} DNS.`, { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('migrate:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/prepublish.ts

@@ -0,0 +1,25 @@
+import process from 'node:process'
+import type { CLI, PrepublishOptions } from '@stacksjs/types'
+import { Action } from '@stacksjs/enums'
+import { runAction } from '@stacksjs/actions'
+
+export function prepublish(buddy: CLI) {
+  const descriptions = {
+    command: 'Run your prepublish script',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('prepublish', descriptions.command)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: PrepublishOptions) => {
+      await runAction(Action.Prepublish, options)
+    })
+
+  buddy.on('prepublish:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/release.ts

@@ -0,0 +1,35 @@
+import process from 'node:process'
+import { Action } from '@stacksjs/enums'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, ReleaseOptions } from '@stacksjs/types'
+import { intro, log, outro } from '@stacksjs/cli'
+import { runAction } from '@stacksjs/actions'
+
+const descriptions = {
+  release: 'Release a new version of your libraries/packages',
+  project: 'Target a specific project',
+  verbose: 'Enable verbose output',
+}
+
+export function release(buddy: CLI) {
+  buddy
+    .command('release', descriptions.release)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: ReleaseOptions) => {
+      const startTime = await intro('buddy release')
+      const result = await runAction(Action.Release, { ...options, stdin: 'inherit' })
+
+      if (result.isErr()) {
+        log.error('Failed to release', result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Triggered your CI/CD release workflow', { startTime, useSeconds: true })
+    })
+
+  buddy.on('release:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/seed.ts

@@ -0,0 +1,38 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, SeedOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+
+export function seed(buddy: CLI) {
+  const descriptions = {
+    seed: 'Seed your database',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('seed', descriptions.seed)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: SeedOptions) => {
+      const perf = await intro('buddy seed')
+      const result = await runAction(Action.Seed, options)
+
+      if (result.isErr()) {
+        await outro('While running the seed command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      const APP_ENV = process.env.APP_ENV || 'local'
+
+      await outro(`Seeded your ${APP_ENV} database.`, { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('seed:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/setup.ts

@@ -0,0 +1,115 @@
+import process from 'node:process'
+import { path as p } from '@stacksjs/path'
+import { handleError } from '@stacksjs/error-handling'
+import { storage } from '@stacksjs/storage'
+import { log, runCommand } from '@stacksjs/cli'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, CliOptions } from '@stacksjs/types'
+
+export function setup(buddy: CLI) {
+  const descriptions = {
+    setup: 'This command ensures your project is setup correctly',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('setup', descriptions.setup)
+    .alias('ensure')
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: CliOptions) => {
+      if (!await isPkgxInstalled())
+        await installPkgx()
+
+      // ensure the minimal amount of deps are written to ./pkgx.yaml
+      await optimizePkgxDeps()
+
+      await initializeProject(options)
+    })
+
+  buddy.on('setup:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(ExitCode.FatalError)
+  })
+}
+
+async function isPkgxInstalled(): Promise<boolean> {
+  const result = await runCommand('pkgx --version', { silent: true })
+
+  if (result.isOk())
+    return true
+
+  return false
+}
+
+async function installPkgx(): Promise<void> {
+  const result = await runCommand(p.frameworkPath('scripts/pkgx-install'))
+
+  if (result.isOk())
+    return
+
+  handleError(result.error)
+  process.exit(ExitCode.FatalError)
+}
+
+async function initializeProject(options: CliOptions): Promise<void> {
+  log.info('Installing dependencies...')
+
+  const result = await runCommand('bun install', {
+    cwd: options.cwd || p.projectPath(),
+  })
+
+  if (result.isErr()) {
+    handleError(result.error)
+    process.exit(ExitCode.FatalError)
+  }
+
+  log.success('Installed node_modules')
+  log.info('Ensuring .env exists...')
+
+  if (storage.doesNotExist(p.projectPath('.env'))) {
+    const envResult = await runCommand('cp .env.example .env', {
+      cwd: options.cwd || p.projectPath(),
+    })
+
+    if (envResult.isErr()) {
+      handleError(envResult.error)
+      process.exit(ExitCode.FatalError)
+    }
+
+    log.success('.env created')
+  }
+  else { log.success('.env existed') }
+
+  const keyResult = await runCommand('buddy key:generate', {
+    cwd: options.cwd || p.projectPath(),
+  })
+
+  if (keyResult.isErr()) {
+    handleError(keyResult.error)
+    process.exit(ExitCode.FatalError)
+  }
+
+  log.info('Ensuring AWS is connected...')
+
+  // const awsResult = await runCommand('buddy configure:aws', {
+  //   cwd: options.cwd || p.projectPath(),
+  // })
+
+  // if (awsResult.isErr()) {
+  //   handleError(awsResult.error)
+  //   process.exit(ExitCode.FatalError)
+  // }
+
+  log.success('Configured AWS')
+
+  // TODO: ensure the IDE is setup by making sure .vscode etc exists, and if not, copy them over
+
+  log.success('Project is setup')
+  log.info('Happy coding! 💙')
+}
+
+export async function optimizePkgxDeps(): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, 300))
+}

package/src/commands/test.ts

@@ -0,0 +1,124 @@
+import process from 'node:process'
+import type { CLI, TestOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+import { Action } from '@stacksjs/enums'
+
+export function test(buddy: CLI) {
+  const descriptions = {
+    command: 'Runs your test suite',
+    types: 'Typechecks your codebase',
+    coverage: 'Generates a test coverage report',
+    ui: 'Runs your test suite in the browser',
+    unit: 'Runs your unit tests',
+    feature: 'Runs your feature tests',
+    showReport: 'Show the test report',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('test', descriptions.command)
+    .option('--ui', descriptions.ui, { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: true })
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test')
+      const result = await runAction(Action.Test, { ...options, cwd: projectPath() })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Finished running tests', { startTime: perf, useSeconds: true })
+    })
+
+  buddy
+    .command('test:unit', descriptions.unit)
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test:unit')
+      const result = await runAction(Action.TestUnit, { ...options, verbose: true, cwd: projectPath() })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test:unit`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Finished running unit tests', { startTime: perf, useSeconds: true })
+    })
+
+  buddy
+    .command('test:feature', descriptions.feature)
+    .option('--show-report', descriptions.showReport, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test:feature')
+      let result
+
+      if (options.showReport)
+        result = await runAction(Action.ShowFeatureTestReport, { ...options, verbose: true, cwd: projectPath() })
+      else
+        result = await runAction(Action.TestFeature, { ...options, verbose: true, cwd: projectPath() })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test:feature`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Finished running feature tests', { startTime: perf, useSeconds: true })
+    })
+
+  buddy
+    .command('test:ui', descriptions.command)
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test:ui')
+      const result = await runAction(Action.TestUi, { ...options, verbose: true, cwd: projectPath() })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test:ui`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Finished running tests in the browser', { startTime: perf, useSeconds: true })
+    })
+
+  buddy
+    .command('test:types', descriptions.types)
+    .alias('typecheck')
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test:types')
+      const result = await runAction(Action.Typecheck, { ...options, verbose: true, cwd: projectPath() })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test:types`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Finished running typecheck', { startTime: perf, useSeconds: true })
+    })
+
+  buddy
+    .command('test:coverage', descriptions.coverage)
+    .action(async (options: TestOptions) => {
+      const perf = await intro('buddy test:coverage')
+      const result = await runAction(Action.TestCoverage, { ...options, cwd: projectPath(), verbose: true })
+
+      if (result.isErr()) {
+        await outro('While running `buddy test:coverage`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Generated the test coverage report', { startTime: perf, useSeconds: true })
+      process.exit()
+    })
+
+  buddy.on('test:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/tinker.ts

@@ -0,0 +1,36 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, TinkerOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+
+export function tinker(buddy: CLI) {
+  const descriptions = {
+    tinker: 'Tinker with your code',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('tinker', descriptions.tinker)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: TinkerOptions) => {
+      const perf = await intro('buddy tinker')
+      const result = await runAction(Action.Tinker, options)
+
+      if (result.isErr()) {
+        await outro('While running the tinker command, there was an issue', { startTime: perf, useSeconds: true }, result.error || undefined)
+        process.exit()
+      }
+
+      await outro('Tinker mode exited.', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('tinker:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/types.ts

@@ -0,0 +1,33 @@
+import process from 'node:process'
+import type { CLI } from '@stacksjs/types'
+import { generateTypes } from '@stacksjs/actions'
+
+export function types(buddy: CLI) {
+  const descriptions = {
+    generate: 'Generate the types of & for your library/libraries',
+    fix: 'wip',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('types:generate', descriptions.generate)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async () => {
+      await generateTypes()
+    })
+
+  buddy
+    .command('types:fix', descriptions.fix)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async () => {
+      // await fixTypes()
+    })
+
+  buddy.on('types:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,115 @@
+import process from 'node:process'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro, prompt } from '@stacksjs/cli'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, UpgradeOptions } from '@stacksjs/types'
+import { Action } from '@stacksjs/enums'
+import { isString } from '@stacksjs/validation'
+
+export function upgrade(buddy: CLI) {
+  const descriptions = {
+    command: 'Upgrade dependencies, framework, package manager, JS/TS runtime',
+    framework: 'Upgrade the Stacks framework',
+    dependencies: 'Upgrade your dependencies (pkgx.yaml & package.json)',
+    bun: 'Upgrade Bun to the latest version',
+    all: 'Upgrade Node, package manager, project dependencies, and framework',
+    force: 'Overwrite possible local updates with remote framework updates',
+    select: 'What are you trying to upgrade?',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('upgrade', descriptions.command)
+    .option('-c, --framework', descriptions.framework, { default: false })
+    .option('-d, --dependencies', descriptions.dependencies, { default: false })
+    .option('-b, --bun', descriptions.bun, { default: false })
+    .option('-a, --all', descriptions.all, { default: false })
+    .option('-f, --force', descriptions.force, { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .alias('update')
+    .example('buddy upgrade -a --verbose')
+    .action(async (options: UpgradeOptions) => {
+      const perf = await intro('buddy upgrade')
+
+      if (hasNoOptions(options)) {
+        let answers = await prompt.require()
+          .multiselect(descriptions.select, {
+            options: [
+              { value: 'dependencies', label: 'Dependencies' },
+              { value: 'framework', label: 'Framework' },
+              { value: 'node', label: 'Node.js' },
+              { value: 'package-manager', label: 'Package Manager' },
+            ],
+          })
+
+        if (answers !== null)
+          process.exit(ExitCode.InvalidArgument)
+
+        if (isString(answers))
+          answers = [answers]
+
+        // creates an object out of array and sets answers to true
+        options = answers.reduce((a: any, v: any) => ({ ...a, [v]: true }), {})
+      }
+
+      const result = await runAction(Action.Upgrade, options)
+
+      if (result.isErr()) {
+        await outro('While running the buddy:upgrade command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro('Upgrade complete.', { startTime: perf, useSeconds: true })
+      process.exit()
+    })
+
+  buddy
+    .command('upgrade:framework', descriptions.framework)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .example('buddy upgrade:framework --verbose')
+    .action(async (options: UpgradeOptions) => {
+      // const perf = await intro('buddy update:framework')
+      await runAction(Action.Upgrade, options)
+    })
+
+  buddy
+    .command('upgrade:dependencies', descriptions.dependencies)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .alias('upgrade:deps')
+    .example('buddy upgrade:dependencies --verbose')
+    .action(async (options: UpgradeOptions) => {
+      await runAction(Action.Upgrade, options)
+    })
+
+  buddy
+    .command('upgrade:bun', descriptions.bun)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: UpgradeOptions) => {
+      const perf = await intro('buddy upgrade:bun')
+      const result = await runAction(Action.UpgradeBun, options)
+
+      if (result.isErr()) {
+        await outro('While running the buddy upgrade:bun command, there was an issue', { startTime: perf, useSeconds: true }, result.error) // FIXME: should not have to cast
+        process.exit()
+      }
+
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('upgrade:all', descriptions.all)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: UpgradeOptions) => {
+      await runAction(Action.Upgrade, options)
+    })
+}
+
+function hasNoOptions(options: UpgradeOptions) {
+  return !options.framework && !options.dependencies && !options.packageManager && !options.node && !options.all
+}

package/src/commands/version.ts

@@ -0,0 +1,24 @@
+import type { CLI } from '@stacksjs/types'
+import { bold, dim, green, intro, log } from '@stacksjs/cli'
+import { storage } from '@stacksjs/storage'
+
+export function version(buddy: CLI) {
+  const descriptions = {
+    version: 'Retrieving Stacks build version',
+  }
+
+  buddy
+    .command('version', descriptions.version)
+    .action(async () => {
+      await intro('buddy version')
+
+      const pkg = await storage.readPackageJson('./package.json')
+      const bunVersion = 'wip'
+      const stacksVersion = pkg.version
+
+      log.info(green(bold('@stacksjs/ ')) + dim(` ${stacksVersion}`))
+      log.info(green(bold('Bun: ')) + dim(`   ${bunVersion}`))
+
+      // redis (or other cache/s), mysql (or other database/s),
+    })
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './commands'