@stacksjs/actions 0.59.10 → 0.61.0

package/src/helpers/package-json.ts

@@ -1,12 +1,17 @@
 import { log } from '@stacksjs/logging'
-import { writeTextFile } from '@stacksjs/storage'
 import { packageJsonPath } from '@stacksjs/path'
+import { writeTextFile } from '@stacksjs/storage'
 import library from '~/config/library'
 
 type PackageJsonType = 'vue-components' | 'web-components' | 'functions'
 
 export async function generatePackageJson(type: PackageJsonType) {
-  let name, description, directory, keywords, config, prettyName
+  let name
+  let description
+  let directory
+  let keywords
+  let config
+  let prettyName
 
   if (type === 'vue-components') {
     name = library.vueComponents?.name
@@ -14,17 +19,13 @@ export async function generatePackageJson(type: PackageJsonType) {
     directory = 'components'
     keywords = library.vueComponents?.keywords
     config = 'vue-components'
-  }
-
-  else if (type === 'web-components') {
+  } else if (type === 'web-components') {
     name = library.webComponents?.name
     description = library.webComponents?.description
     directory = 'components'
     keywords = library.webComponents?.keywords
     config = 'web-components'
-  }
-
-  else if (type === 'functions') {
+  } else if (type === 'functions') {
     name = library.functions?.name
     description = library.functions?.description
     directory = 'functions'
@@ -81,16 +82,12 @@ export async function generatePackageJson(type: PackageJsonType) {
 `,
     })
 
-    if (type === 'vue-components')
-      prettyName = 'Vue Component library'
-    else if (type === 'web-components')
-      prettyName = 'Web Component library'
-    else if (type === 'functions')
-      prettyName = 'Function Library'
+    if (type === 'vue-components') prettyName = 'Vue Component library'
+    else if (type === 'web-components') prettyName = 'Web Component library'
+    else if (type === 'functions') prettyName = 'Function Library'
 
     log.success(`Created ${prettyName} package.json file`)
-  }
-  catch (err) {
+  } catch (err) {
     log.error(`There was an error creating the ${prettyName} package.json`, err)
   }
 }

package/src/helpers/utils.ts

@@ -1,9 +1,15 @@
+import type { Action as ActionType } from '@stacksjs/actions'
 import { buddyOptions, runCommand, runCommands } from '@stacksjs/cli'
-import { storage } from '@stacksjs/storage'
-import { log } from '@stacksjs/logging'
 import { err } from '@stacksjs/error-handling'
+import { log } from '@stacksjs/logging'
 import * as p from '@stacksjs/path'
+import { glob, storage } from '@stacksjs/storage'
 import type { ActionOptions } from '@stacksjs/types'
+import { Glob } from 'bun'
+
+type ActionPath = string // TODO: narrow this by automating its generation
+type ActionName = string // TODO: narrow this by automating its generation
+type Action = ActionPath | ActionName | string
 
 /**
  * Run an Action the Stacks way.
@@ -12,7 +18,23 @@ import type { ActionOptions } from '@stacksjs/types'
  * @param options The options to pass to the command.
  * @returns The result of the command.
  */
-export async function runAction(action: string, options?: ActionOptions) {
+export async function runAction(action: Action, options?: ActionOptions) {
+  // check if action is a file anywhere in ./app/Actions/**/*.ts
+  // if it is, return and await the action
+  const glob = new Glob('**/*.ts')
+  const scanOptions = { cwd: p.userActionsPath(), onlyFiles: true }
+
+  for await (const file of glob.scan(scanOptions)) {
+    log.debug('file', file)
+    if (file === `${action}.ts` || file.endsWith(`${action}.ts`))
+      return ((await import(p.userActionsPath(file))).default as ActionType).handle()
+
+    // if a custom model name is used, we need to check for it
+    const a = await import(p.userActionsPath(file))
+    if (a.name === action) return await a.handle()
+  }
+
+  // or else, just run the action normally by assuming the action is core Action,  stored in p.actionsPath
   const opts = buddyOptions()
   const path = p.relativeActionsPath(`src/${action}.ts`)
   const cmd = `bun --bun ${path} ${opts}`.trimEnd()
@@ -34,17 +56,14 @@ export async function runAction(action: string, options?: ActionOptions) {
  * @param options The options to pass to the command.
  * @returns The result of the command.
  */
-export async function runActions(actions: string[], options?: ActionOptions) {
-  log.debug('runActions:', actions)
-  log.debug('actions options:', options)
+export async function runActions(actions: Action[], options?: ActionOptions) {
+  log.debug('runActions:', actions, options)
 
-  if (!actions.length)
-    return err('No actions were specified')
+  if (!actions.length) return err('No actions were specified')
 
   for (const action of actions) {
     log.debug(`running action "${action}"`)
-    if (!hasAction(action))
-      return err(`The specified action "${action}" does not exist`)
+    if (!hasAction(action)) return err(`The specified action "${action}" does not exist`)
   }
 
   const opts = buddyOptions()
@@ -54,13 +73,37 @@ export async function runActions(actions: string[], options?: ActionOptions) {
     ...options,
   }
 
-  const commands = actions.map(action => `bun --bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`)
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`)
 
   log.debug('commands:', commands)
 
   return await runCommands(commands, o)
 }
 
-export function hasAction(action: string) {
-  return storage.isFile(p.actionsPath(`src/${action}.ts`))
+// looks in most common locations
+export function hasAction(action: Action) {
+  // Define patterns specifically for user actions
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`,
+  ]
+
+  // Define patterns specifically for core actions
+  const actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`]
+
+  // Check user actions path with its specific patterns
+  const userActionFiles = glob.sync(userActionPatterns.map((pattern) => p.userActionsPath(pattern)))
+
+  // Check actions path with its specific patterns
+  const actionFiles = glob.sync(actionPatterns.map((pattern) => p.actionsPath(pattern)))
+
+  return userActionFiles.length > 0 || actionFiles.length > 0
+
+  // TODO: need to loop through all user actions and check whether the name is a valid action name match
+
+  // return false
 }

package/src/helpers/vscode-custom-data.ts

@@ -13,8 +13,7 @@ export async function generateVsCodeCustomData() {
       data: generateComponentInfoData(),
     })
     log.success('Generated custom-elements.json for IDEs.')
-  }
-  catch (err) {
+  } catch (err) {
     log.error('There was an error generating the custom-elements.json file.', err)
   }
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from './action'
 export * from './dev'
 export * from './generate'
-export * from './helpers/utils'
+export * from './helpers'
 
 export { commit as runCommit } from './commit'
 export { add as runAdd } from './add'
@@ -9,6 +9,7 @@ export { add as runAdd } from './add'
 // makeFactory,
 export {
   make as runMake,
+  makeAction,
   makeComponent,
   makeDatabase,
   makeFunction,

package/src/key-generate.ts

@@ -1,10 +1,9 @@
 import { runCommand } from '@stacksjs/cli'
-import { isFile } from '@stacksjs/storage'
-import { setEnvValue } from '@stacksjs/utils'
 import { projectPath } from '@stacksjs/path'
 import { generateAppKey } from '@stacksjs/security'
+import { isFile } from '@stacksjs/storage'
+import { setEnvValue } from '@stacksjs/utils'
 
-if (!isFile('.env'))
-  await runCommand('cp .env.example .env', { cwd: projectPath() })
+if (!isFile('.env')) await runCommand('cp .env.example .env', { cwd: projectPath() })
 
 await setEnvValue('APP_KEY', generateAppKey())

package/src/lint/fix.ts

@@ -1,14 +1,22 @@
 import { log, parseOptions, runCommand } from '@stacksjs/cli'
-import { projectPath } from '@stacksjs/path'
 import { NpmScript } from '@stacksjs/enums'
+import { projectPath } from '@stacksjs/path'
+import { ExitCode } from '@stacksjs/types'
 
 // TODO: this should be a loader
 log.info('Ensuring Code Style...')
 
 const options = parseOptions()
-await runCommand(NpmScript.LintFix, {
+
+const result = await runCommand(NpmScript.LintFix, {
   cwd: projectPath(),
   ...options,
 })
 
+// console.log('rs', result.error)
+// if (result.isErr()) {
+//   log.error('There was an error fixing your code style.', result.error)
+//   process.exit(1)
+// }
+
 log.success('Linted')

package/src/lint/index.ts

@@ -1,10 +1,8 @@
 import process from 'node:process'
-import { ExitCode } from '@stacksjs/types'
-import { NpmScript } from '@stacksjs/enums'
 import { log, runCommands } from '@stacksjs/cli'
+import { NpmScript } from '@stacksjs/enums'
 import { projectPath } from '@stacksjs/path'
-
-// import { $ } from 'bun'
+import { ExitCode } from '@stacksjs/types'
 
 log.info('Ensuring Code Style...')
 
@@ -14,14 +12,12 @@ log.info('Ensuring Code Style...')
 // await $`${NpmScript.Lint}`
 // await $`${NpmScript.LintPackageJson}`
 
-const result = await runCommands([
-  NpmScript.Lint,
-  NpmScript.LintPackageJson,
-], { cwd: projectPath() })
+const result = await runCommands([NpmScript.Lint, NpmScript.LintPackageJson], {
+  cwd: projectPath(),
+})
 
 if (Array.isArray(result)) {
-  if (result.map(r => r.isErr()).includes(true))
-    process.exit(ExitCode.FatalError)
+  if (result.map((r) => r.isErr()).includes(true)) process.exit(ExitCode.FatalError)
 }
 
 log.success('Linted')

package/src/make.ts

@@ -1,59 +1,75 @@
 import process from 'node:process'
 import { italic } from '@stacksjs/cli'
 import { log } from '@stacksjs/logging'
+import { frameworkPath, path as p, projectPath, resolve } from '@stacksjs/path'
 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.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)
+  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 makeAction(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your action...')
+    await createAction(options)
+    log.success(`Created ${italic(name)} action`)
+  } catch (error) {
+    log.error('There was an error creating your action', error)
+    process.exit()
+  }
+}
+
 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) {
+  } catch (error) {
     log.error('There was an error creating your component', error)
     process.exit()
   }
 }
 
+export async function createAction(options: MakeOptions) {
+  const name = options.name
+  await writeTextFile({
+    path: p.userActionsPath(`${name}.ts`),
+    data: `import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: '${name}',
+  description: '${name} action',
+
+  handle() {
+    return 'Hello World action'
+  },
+})
+`,
+  })
+}
+
 export async function createComponent(options: MakeOptions) {
   const name = options.name
   await writeTextFile({
-    path: `./components/${name}.stx`,
+    path: p.userComponentsPath(`${name}.stx`),
     data: `<script setup lang="ts">
-// eslint-disable-next-line no-console
 console.log('Hello World component created')
 </script>
 
@@ -72,16 +88,14 @@ export function makeDatabase(options: MakeOptions) {
     log.info(`Creating your ${italic(name)} database...`)
     createDatabase(options)
     log.success(`Created ${italic(name)} database`)
-  }
-  catch (error) {
+  } 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
+  console.log('createDatabase options', options) // wip
 }
 
 export function factory(options: MakeOptions) {
@@ -90,15 +104,13 @@ export function factory(options: MakeOptions) {
     log.info(`Creating your ${italic(name)} factory...`)
     createDatabase(options)
     log.success(`Created ${italic(name)} factory`)
-  }
-  catch (error) {
+  } 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
 }
 
@@ -108,8 +120,7 @@ export async function makeNotification(options: MakeOptions) {
     log.info(`Creating your ${italic(name)} notification...`)
     await createNotification(options)
     log.success(`Created ${italic(name)} notification`)
-  }
-  catch (error) {
+  } catch (error) {
     log.error('There was an error creating your notification', error)
     process.exit()
   }
@@ -121,8 +132,7 @@ export async function makePage(options: MakeOptions) {
     log.info('Creating your page...')
     await createPage(options)
     log.success(`Created ${name} page`)
-  }
-  catch (error) {
+  } catch (error) {
     log.error('There was an error creating your page', error)
     process.exit()
   }
@@ -131,10 +141,8 @@ export async function makePage(options: MakeOptions) {
 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
+    path: p.userViewsPath(`${name}.stx`),
+    data: `<script setup lang="ts">
 console.log('Hello World page created')
 </script>
 
@@ -153,8 +161,7 @@ export async function makeFunction(options: MakeOptions) {
     log.info('Creating your function...')
     await createFunction(options)
     log.success(`Created ${name} function`)
-  }
-  catch (error) {
+  } catch (error) {
     log.error('There was an error creating your function', error)
     process.exit()
   }
@@ -163,7 +170,7 @@ export async function makeFunction(options: MakeOptions) {
 export async function createFunction(options: MakeOptions) {
   const name = options.name
   await writeTextFile({
-    path: `./functions/${name}.ts`,
+    path: p.userFunctionsPath(`${name}.ts`),
     data: `// reactive state
 const ${name} = ref(0)
 
@@ -186,8 +193,7 @@ export async function makeLanguage(options: MakeOptions) {
     log.info('Creating your translation file...')
     await createLanguage(options)
     log.success(`Created ${name} translation file`)
-  }
-  catch (error) {
+  } catch (error) {
     log.error('There was an error creating your language.', error)
     process.exit()
   }
@@ -196,7 +202,7 @@ export async function makeLanguage(options: MakeOptions) {
 export async function createLanguage(options: MakeOptions) {
   const name = options.name
   await writeTextFile({
-    path: `./lang/${name}.yml`,
+    path: p.resourcesPath(`lang/${name}.yml`),
     data: `button:
   text: Copy
 `,
@@ -212,8 +218,7 @@ export function makeStack(options: MakeOptions) {
     // await spawn(`giget stacks ${path}`)
     log.success('Successfully scaffolded your project')
     log.info(`cd ${path} && bun install`)
-  }
-  catch (error) {
+  } catch (error) {
     log.error('There was an error creating your stack', error)
     process.exit()
   }
@@ -224,17 +229,14 @@ export async function createNotification(options: MakeOptions) {
   try {
     let importOption = 'EmailOptions'
 
-    if (!doesFolderExist('notifications'))
-      await createFolder('./notifications')
+    if (!doesFolderExist('notifications')) await createFolder('./notifications')
 
-    if (options.chat)
-      importOption = 'ChatOptions'
+    if (options.chat) importOption = 'ChatOptions'
 
-    if (options.sms)
-      importOption = 'SMSOptions'
+    if (options.sms) importOption = 'SMSOptions'
 
     await writeTextFile({
-      path: `./notifications/${name}.ts`,
+      path: p.userNotificationsPath(`${name}.ts`),
       data: `import type { ${importOption} } from \'@stacksjs/types\'
 
 function content(): string {
@@ -249,8 +251,7 @@ function send(): ${importOption} {
     })
 
     return true
-  }
-  catch (error) {
+  } catch (error) {
     return false
   }
 }
@@ -259,6 +260,9 @@ export async function createMigration(options: MakeOptions) {
   const optionName = options.name
   // const table = options.tableName
   const table = 'dummy-name'
+
+  if (!optionName[0]) throw new Error('options.name is required and cannot be empty')
+
   const name = optionName[0].toUpperCase() + optionName.slice(1)
   const path = frameworkPath(`database/migrations/${name}.ts`)
 
@@ -270,53 +274,51 @@ export async function createMigration(options: MakeOptions) {
 export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('${table}')
-    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .addColumn('id', 'integer', col => col.autoIncrement().primaryKey())
     .execute()
 }`,
     })
 
     log.success(`Successfully created your migration file at stacks/database/migrations/${name}.ts`)
-  }
-  catch (error) {
+  } catch (error: any) {
     log.error(error)
   }
 }
 
 export async function createModel(options: MakeOptions) {
   const optionName = options.name
+
+  if (!optionName[0]) throw new Error('options.name is required and cannot be empty')
+
   const name = optionName[0].toUpperCase() + optionName.slice(1)
-  const path = projectPath(`app/Models/${name}.ts`)
+  const path = p.userModelsPath(`${name}.ts`)
+
   try {
     await writeTextFile({
       path: `${path}`,
       data: `import { faker } from '@stacksjs/faker'
-import { validate } from '@stacksjs/validation'
+import { schema } from '@stacksjs/validation'
 import type { Model } from '@stacksjs/types'
 
-export default <Model> {
+export default {
   name: '${name}',
 
-  searchable: true, // boolean | IndexSettings,
-  authenticatable: true, // boolean | AuthSettings,
+  traits: {
+    useTimestamps: true,
 
-  seeder: {
-    count: 10,
-  },
-
-  fields: {
-    name: {
-      validation: validate.string().min(3).max(255),
-      factory: () => faker.person,
+    useSeeder: {
+      count: 10,
     },
+  },
 
-    // more fields here
+  attributes: {
+    // your attributes here
   },
-}`,
+} satisfies Model`,
     })
 
-    log.success(`Successfully created your model at app/Models/${name}.ts`)
-  }
-  catch (error) {
+    log.success(`Model created: ${italic(`app/Models/${name}.ts`)}`)
+  } catch (error: any) {
     log.error(error)
   }
 }

package/src/migrate/database.ts

@@ -1 +1,22 @@
-// wip
+import process from 'node:process'
+import { generateMigrations, runDatabaseMigration } from '@stacksjs/database'
+import { log } from '@stacksjs/logging'
+
+// this is run and checks whether new created or update migrations need to be generated
+const result = await generateMigrations()
+
+if (result?.isErr()) {
+  console.error(result.error)
+  log.error('[stacks] generateMigrations failed', result.error)
+  process.exit(1)
+}
+
+const result2 = await runDatabaseMigration()
+
+if (result2.isErr()) {
+  log.error('runDatabaseMigration failed')
+  log.error(result2.error)
+  process.exit(1)
+}
+
+process.exit(0)

package/src/migrate/fresh.ts

@@ -0,0 +1,20 @@
+import process from 'node:process'
+import { generateMigrations, resetDatabase, runDatabaseMigration } from '@stacksjs/database'
+import { log } from '@stacksjs/logging'
+
+// first, reset the database, if it exists
+const result = await resetDatabase()
+
+if (result?.isErr()) {
+  console.error(result.error)
+  log.error('generateMigrations failed', result.error)
+  process.exit(1)
+}
+
+// then,generate the migrations
+await generateMigrations()
+
+// finally, migrate the database
+await runDatabaseMigration()
+
+process.exit(0)