@stacksjs/actions 0.58.48 → 0.58.50

package/src/make.ts

@@ -0,0 +1,322 @@
+import process from 'node:process'
+import { italic } from '@stacksjs/cli'
+import { log } from '@stacksjs/logging'
+import { createFolder, doesFolderExist, writeTextFile } from '@stacksjs/storage'
+import { frameworkPath, projectPath, resolve } from '@stacksjs/path'
+import type { MakeOptions } from '@stacksjs/types'
+
+export async function invoke(options: MakeOptions) {
+  if (options.component)
+    await makeComponent(options)
+
+  if (options.database)
+    makeDatabase(options)
+
+  if (options.function)
+    await makeFunction(options)
+
+  if (options.language)
+    await makeLanguage(options)
+
+  // if (options.migration)
+  //   await migration(options)
+
+  if (options.notification)
+    await makeNotification(options)
+
+  if (options.page)
+    await makePage(options)
+
+  if (options.stack)
+    makeStack(options)
+}
+
+export async function make(options: MakeOptions) {
+  return invoke(options)
+}
+
+export async function makeComponent(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your component...')
+    await createComponent(options)
+    log.success(`Created ${italic(name)} component`)
+  }
+  catch (error) {
+    log.error('There was an error creating your component', error)
+    process.exit()
+  }
+}
+
+export async function createComponent(options: MakeOptions) {
+  const name = options.name
+  await writeTextFile({
+    path: `./components/${name}.stx`,
+    data: `<script setup lang="ts">
+// eslint-disable-next-line no-console
+console.log('Hello World component created')
+</script>
+
+<template>
+  <div>
+    Some HTML block
+  </div>
+</template>
+`,
+  })
+}
+
+export function makeDatabase(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} database...`)
+    createDatabase(options)
+    log.success(`Created ${italic(name)} database`)
+  }
+  catch (error) {
+    log.error('There was an error creating your database', error)
+    process.exit()
+  }
+}
+
+export function createDatabase(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export function factory(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} factory...`)
+    createDatabase(options)
+    log.success(`Created ${italic(name)} factory`)
+  }
+  catch (error) {
+    log.error('There was an error creating your factory', error)
+    process.exit()
+  }
+}
+
+export function createFactory(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export async function makeNotification(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} notification...`)
+    await createNotification(options)
+    log.success(`Created ${italic(name)} notification`)
+  }
+  catch (error) {
+    log.error('There was an error creating your notification', error)
+    process.exit()
+  }
+}
+
+export async function makePage(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your page...')
+    await createPage(options)
+    log.success(`Created ${name} page`)
+  }
+  catch (error) {
+    log.error('There was an error creating your page', error)
+    process.exit()
+  }
+}
+
+export async function createPage(options: MakeOptions) {
+  const name = options.name
+  await writeTextFile({
+    path: `./pages/${name}.stx`,
+    data:
+`<script setup lang="ts">
+// eslint-disable-next-line no-console
+console.log('Hello World page created')
+</script>
+
+<template>
+  <div>
+    Visit http://127.0.0.1/${name}
+  </div>
+</template>
+`,
+  })
+}
+
+export async function makeFunction(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your function...')
+    await createFunction(options)
+    log.success(`Created ${name} function`)
+  }
+  catch (error) {
+    log.error('There was an error creating your function', error)
+    process.exit()
+  }
+}
+
+export async function createFunction(options: MakeOptions) {
+  const name = options.name
+  await writeTextFile({
+    path: `./functions/${name}.ts`,
+    data: `// reactive state
+const ${name} = ref(0)
+
+// functions that mutate state and trigger updates
+function increment() {
+  ${name}.value++
+}
+
+export {
+  ${name},
+  increment,
+}
+`,
+  })
+}
+
+export async function makeLanguage(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your translation file...')
+    await createLanguage(options)
+    log.success(`Created ${name} translation file`)
+  }
+  catch (error) {
+    log.error('There was an error creating your language.', error)
+    process.exit()
+  }
+}
+
+export async function createLanguage(options: MakeOptions) {
+  const name = options.name
+  await writeTextFile({
+    path: `./lang/${name}.yml`,
+    data: `button:
+  text: Copy
+`,
+  })
+}
+
+export function makeStack(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${name} stack...`)
+    const path = resolve(process.cwd(), name)
+
+    // await spawn(`giget stacks ${path}`)
+    log.success('Successfully scaffolded your project')
+    log.info(`cd ${path} && bun install`)
+  }
+  catch (error) {
+    log.error('There was an error creating your stack', error)
+    process.exit()
+  }
+}
+
+export async function createNotification(options: MakeOptions) {
+  const name = options.name
+  try {
+    let importOption = 'EmailOptions'
+
+    if (!doesFolderExist('notifications'))
+      await createFolder('./notifications')
+
+    if (options.chat)
+      importOption = 'ChatOptions'
+
+    if (options.sms)
+      importOption = 'SMSOptions'
+
+    await writeTextFile({
+      path: `./notifications/${name}.ts`,
+      data: `import type { ${importOption} } from \'@stacksjs/types\'
+
+function content(): string {
+  return 'example'
+}
+
+function send(): ${importOption} {
+  return {
+    content: content(),
+  }
+}`,
+    })
+
+    return true
+  }
+  catch (error) {
+    return false
+  }
+}
+
+export async function createMigration(options: MakeOptions) {
+  const optionName = options.name
+  // const table = options.tableName
+  const table = 'dummy-name'
+  const name = optionName[0].toUpperCase() + optionName.slice(1)
+  const path = frameworkPath(`database/migrations/${name}.ts`)
+
+  try {
+    await writeTextFile({
+      path: `${path}`,
+      data: `import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('${table}')
+    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .execute()
+}`,
+    })
+
+    log.success(`Successfully created your migration file at stacks/database/migrations/${name}.ts`)
+  }
+  catch (error) {
+    log.error(error)
+  }
+}
+
+export async function createModel(options: MakeOptions) {
+  const optionName = options.name
+  const name = optionName[0].toUpperCase() + optionName.slice(1)
+  const path = projectPath(`app/Models/${name}.ts`)
+  try {
+    await writeTextFile({
+      path: `${path}`,
+      data: `import { faker } from '@stacksjs/faker'
+import { validate } from '@stacksjs/validation'
+import type { Model } from '@stacksjs/types'
+
+export default <Model> {
+  name: '${name}',
+
+  searchable: true, // boolean | IndexSettings,
+  authenticatable: true, // boolean | AuthSettings,
+
+  seeder: {
+    count: 10,
+  },
+
+  fields: {
+    name: {
+      validation: validate.string().min(3).max(255),
+      factory: () => faker.person,
+    },
+
+    // more fields here
+  },
+}`,
+    })
+
+    log.success(`Successfully created your model at app/Models/${name}.ts`)
+  }
+  catch (error) {
+    log.error(error)
+  }
+}

package/src/migrate/database.ts

@@ -0,0 +1 @@
+// wip

package/src/migrate/dns.ts

@@ -0,0 +1,3 @@
+import { generateMigrations } from './generate'
+
+generateMigrations()

package/src/prepublish.ts

@@ -0,0 +1,17 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { runtimePath } from '@stacksjs/path'
+import { runNpmScript } from '@stacksjs/utils'
+import { NpmScript } from '@stacksjs/enums'
+
+log.info('Running prepublish command...')
+
+// right before we publish, we need to build Stacks
+const result = await runNpmScript(NpmScript.BuildStacks, { verbose: true, cwd: runtimePath() })
+
+if (result.isErr()) {
+  log.error(new Error('There was an error while prepublishing your stack'), result.error)
+  process.exit()
+}
+
+log.success('Prepublishing completed')

package/src/release.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env bun
+import { projectPath } from '@stacksjs/path'
+import { Action } from '@stacksjs/enums'
+import { log } from '@stacksjs/logging'
+import { app } from '@stacksjs/config'
+import { runActions } from '.'
+
+await runActions([
+  Action.GenerateLibraryEntries, // generates the package/library entry points
+  Action.LintFix, // ensure there are no lint errors
+  // Action.Test, // run the tests
+  Action.Bump, // bump the versions, create the git tag, generate the changelog, commit & push the changes
+], { cwd: projectPath(), stdin: 'inherit' }) // debug mode needs to be enabled to see the output due to the interactive prompts
+
+log.success(`Successfully released ${app.name}`)

package/src/start-caddy.ts

@@ -0,0 +1,13 @@
+import { handleError } from '@stacksjs/error-handling'
+import { runCommand } from '@stacksjs/cli'
+import { path as p } from '@stacksjs/path'
+
+// eslint-disable-next-line no-console
+console.log('Starting Caddy...')
+
+const result = await runCommand('caddy run', {
+  cwd: p.frameworkPath(),
+})
+
+if (result.isErr())
+  handleError(result.error)

package/src/test/coverage.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand(NpmScript.TestCoverage, { cwd: frameworkPath(), verbose: true })

package/src/test/feature.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand(NpmScript.TestFeature, { verbose: true, cwd: frameworkPath() })

package/src/test/ui.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand(NpmScript.TestUi, { verbose: true, cwd: frameworkPath() })

package/src/test/unit.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand(NpmScript.TestUnit, { verbose: true, cwd: frameworkPath() })

package/src/test.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand(NpmScript.Test, { verbose: true, cwd: frameworkPath() })

package/src/tinker.ts

@@ -0,0 +1,10 @@
+import { parseArgs } from '@stacksjs/cli'
+
+const options = parseArgs()
+
+// eslint-disable-next-line no-console
+console.log('options are:', options)
+
+// await runCommands([
+//   'bunx tinker',
+// ], { verbose: true })

package/src/typecheck.ts

@@ -0,0 +1,5 @@
+import { NpmScript } from '@stacksjs/enums'
+import { runCommands } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+
+await runCommands([NpmScript.TestTypes], { cwd: projectPath() })

package/src/types.ts

@@ -0,0 +1,20 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { runNpmScript } from '@stacksjs/utils'
+import type { TypesOptions } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/enums'
+
+export async function invoke(options?: TypesOptions) {
+  const results = await runNpmScript(NpmScript.TypesFix, options)
+
+  if (results.isErr()) {
+    log.error('There was an error fixing your types.', results.error)
+    process.exit()
+  }
+
+  log.success('Types are set')
+}
+
+export async function types(options: TypesOptions) {
+  return invoke(options)
+}

package/src/upgrade/bun.ts

@@ -0,0 +1,4 @@
+// import { parseArgs, runCommand } from '@stacksjs/cli'
+// import { NpmScript } from '@stacksjs/enums'
+//
+// await runCommand(NpmScript.UpgradeBun, parseArgs())

package/src/upgrade/framework.ts

@@ -0,0 +1,30 @@
+// import { outro } from '@stacksjs/cli'
+// import { log } from '@stacksjs/logging'
+// import * as storage from '@stacksjs/storage'
+// import { determineDebugLevel, loop } from '@stacksjs/utils'
+// import { frameworkPath, projectPath } from '@stacksjs/path'
+//
+// // await runCommand(NpmScript.UpgradeFramework, parseArgs())
+//
+// await checkForUncommittedChanges('./stacks', options)
+// await downloadFrameworkUpdate(options)
+//
+// log.info('Updating framework...')
+//
+// const exclude = ['functions/package.json', 'components/vue/package.json', 'components/web/package.json', 'auto-imports.d.ts', 'components.d.ts', 'dist']
+// await storage.deleteFiles(frameworkPath(), exclude)
+//
+// // loop 5 times to make sure all "deep empty" folders are deleted
+// loop(5, async () => {
+//   await storage.deleteEmptyFolders(frameworkPath())
+// })
+//
+// await storage.copyFolder(frameworkPath(), projectPath('./updates/stacks'), exclude)
+//
+// if (determineDebugLevel(options))
+//   log.info('Cleanup...')
+//
+// await storage.deleteFolder(projectPath('updates'))
+//
+// outro('Framework updated', { startTime: perf, useSeconds: true })
+// process.exit()

package/src/upgrade/index.ts

@@ -0,0 +1,21 @@
+import process from 'node:process'
+import { ExitCode, parseArgs } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+import { runAction } from '../helpers'
+
+const options = parseArgs()
+
+// run all the upgrade actions
+if (options?.framework || options?.all)
+  await updateFramework(options)
+
+if (options?.dependencies || options?.all)
+  await updateDependencies(options)
+
+if (options?.bun || options?.all)
+  await runAction(Action.UpgradeBun, options)
+
+process.exit(ExitCode.InvalidArgument)
+
+// TODO: also update CI files & configurations, and other files, possibly (taze?)
+// we want this to be smart enough to update only if files that have been updated

package/src/upgrade.ts

@@ -0,0 +1,65 @@
+import process from 'node:process'
+import { intro, outro, runCommand } from '@stacksjs/cli'
+import { log } from '@stacksjs/logging'
+import { projectPath } from '@stacksjs/path'
+import * as storage from '@stacksjs/storage'
+import type { UpgradeOptions } from '@stacksjs/types'
+import { version } from '../package.json'
+
+// import { determineDebugLevel } from '@stacksjs/utils'
+
+// export async function checkForUncommittedChanges(path = './stacks', options: UpgradeOptions) {
+export function checkForUncommittedChanges(options: UpgradeOptions) {
+  try {
+    // const stdio = determineDebugLevel(options) ? 'inherit' : 'ignore'
+
+    // check if the stacks folder has any updates
+    // https://carlosbecker.com/posts/git-changed/
+    // await spawn(`git diff --quiet HEAD -- ${path}`, { stdio, cwd: projectPath() })
+  }
+  catch (error: any) {
+    if (error.status === 1) {
+      // even though the ./stacks folder should not be edited, instead config values should be adjusted,
+      // there is a chance that users may apply local core edits, as it's totally acceptable, as long as
+      // the user knows what they are doing. There is also a change that simply the deps within stacks
+      // folder have been updated and that could produce a diff.
+      if (!options?.force) {
+        // const confirmed = await log.prompt('We detected there are uncommitted in the ./stacks folder. Do you want to overwrite those?', {
+        //   type: 'confirm',
+        // })
+
+        // if (!confirmed) {
+        //   log.info('Aborted. Stacks did not update itself.')
+        //   log.info('Note: if you commit your changes and replay the update, you can see what changed.')
+        //   process.exit(ExitCode.Success)
+        // }
+      }
+    }
+  }
+}
+
+export async function downloadFrameworkUpdate(options: UpgradeOptions) {
+  const tempFolderName = 'updates'
+  const tempUpdatePath = projectPath(tempFolderName)
+
+  if (storage.doesFolderExist(tempUpdatePath))
+    await deleteFolder(tempUpdatePath)
+
+  log.info('Downloading framework updates...')
+  await runCommand(`giget stacks ${tempFolderName}`, options)
+  log.success(`Your framework updated correctly to version: v${version}`)
+}
+
+// export async function updateDependencies(options: UpgradeOptions) {
+export async function updateDependencies() {
+  const perf = await intro('buddy upgrade:dependencies')
+  const result = await runCommand(NpmScript.UpgradeDependencies, options)
+
+  if (result.isErr()) {
+    outro('While running the upgrade:dependencies command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+    process.exit()
+  }
+
+  await outro('Freshly updated your dependencies.', { startTime: perf, useSeconds: true })
+  process.exit()
+}

package/src/zip/api.ts

@@ -0,0 +1,22 @@
+// TODO: we likely won't need this once we use docker images for the runtime
+// zip the api for deployment
+import { log } from '@stacksjs/logging'
+import { path as p } from '@stacksjs/path'
+import { zip } from '@stacksjs/storage'
+
+log.info('zipping your API for Lambda usage...')
+
+const from = [
+  'bootstrap',
+  'runtime.ts',
+  'server.js',
+]
+
+const to = p.projectStoragePath('framework/cloud/api.zip')
+
+// zip all the paths into a single file
+await zip(from, to, {
+  cwd: p.cloudPath('src/runtime'),
+})
+
+log.info('Zipped your API')