stacks 0.41.1 → 0.44.9

package/core/actions/src/helpers/package-json.ts

@@ -0,0 +1,95 @@
+import { log } from '@stacksjs/logging'
+import { writeTextFile } from '@stacksjs/storage'
+import { packageJsonPath } from '@stacksjs/path'
+import { library } from '@stacksjs/config'
+import { packageManager } from '../../package.json' assert { type: 'json' }
+
+export async function generatePackageJson(type: 'vue-components' | 'web-components' | 'functions') {
+  let name, description, directory, keywords, config, prettyName
+
+  if (type === 'vue-components') {
+    name = library.vueComponents.name
+    description = library.vueComponents.description
+    directory = 'components'
+    keywords = library.vueComponents.keywords
+    config = 'vue-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') {
+    name = library.functions.name
+    description = library.functions.description
+    directory = 'functions'
+    keywords = library.functions.keywords
+    config = 'functions'
+  }
+
+  try {
+    // the version does not have to be set here,
+    // it will be set automatically by the release script
+    await writeTextFile({
+      path: packageJsonPath(type),
+      data: `{
+  "name": "${name}",
+  "type": "module",
+  "version": "",
+  "packageManager": "${packageManager}",
+  "description": "${description}",
+  "author": "${library.author}",
+  "license": "MIT",
+  "homepage": "https://github.com/${library.repository}/tree/main/${directory}#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/${library.repository}.git",
+    "directory": "${directory}"
+  },
+  "bugs": {
+    "url": "https://github.com/${library.repository}/issues"
+  },
+  "keywords": ${JSON.stringify(keywords)},
+  "contributors": ${JSON.stringify(library.contributors)},
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build -c ../build/${config}.ts",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "stacks": "workspace:*"
+  }
+}
+`,
+    })
+
+    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`)
+  }
+  catch (err) {
+    log.error(`There was an error creating the ${prettyName} package.json.`, err)
+  }
+}

package/core/actions/src/helpers/utils.ts

@@ -0,0 +1,30 @@
+import storage from '@stacksjs/storage'
+import { runCommand } from '@stacksjs/cli'
+import { actionsPath, functionsPath } from '@stacksjs/path'
+import type { CliOptions } from '@stacksjs/types'
+import { err } from '@stacksjs/error-handling'
+
+/**
+ * Run a command the Stacks way.
+ *
+ * @param command The action to invoke.
+ * @param options The options to pass to the command.
+ * @returns The result of the command.
+ */
+export async function runAction(action: string, options?: CliOptions) {
+  if (!hasAction(action))
+    return err(`The specified action "${action}" does not exist`)
+
+  const cmd = `esno ${actionsPath(`${action}.ts`)}`
+  return await runCommand(cmd, options)
+}
+
+export function hasAction(action: string) {
+  if (storage.isFile(functionsPath(`actions/${action}.ts`)))
+    return true
+
+  if (storage.isFile(actionsPath(`${action}.ts`)))
+    return true
+
+  return false
+}

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

@@ -0,0 +1,28 @@
+import { log } from '@stacksjs/logging'
+import { customElementsDataPath } from '@stacksjs/path'
+import { writeTextFile } from '@stacksjs/storage'
+import { library } from '@stacksjs/config'
+
+export async function generateVsCodeCustomData() {
+  try {
+    // the version does not have to be set here,
+    // it will be set automatically by the release script
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData(),
+    })
+  }
+  catch (err) {
+    log.error('There was an error generating the VS Code custom data file.', err)
+  }
+}
+
+function generateComponentInfoData() {
+  const componentsData = JSON.stringify(library.vueComponents.tags)
+
+  return `{
+  "version": 1.1,
+  "tags": ${componentsData}
+}
+`
+}

package/core/actions/src/helpers/vue-compat.ts

@@ -0,0 +1,17 @@
+import fg from 'fast-glob'
+import fs from 'fs-extra'
+
+export async function generateVueCompat(paths: string[]) {
+  const files = await fg(paths, {
+    onlyFiles: true,
+  })
+
+  for (const f of files) {
+    const raw = await fs.readFile(f, 'utf-8')
+    const changed = raw
+      .replace(/"@vue\/composition-api"/g, '\'vue-demi\'')
+      .replace(/"vue"/g, '\'vue-demi\'')
+      .replace(/'vue'/g, '\'vue-demi\'')
+    await fs.writeFile(f, changed, 'utf-8')
+  }
+}

package/core/actions/src/index.ts

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

package/core/actions/src/key.ts

@@ -0,0 +1,48 @@
+import { getRandomValues } from 'node:crypto'
+import { log, runCommand } from '@stacksjs/cli'
+// import { generateAppKey } from '@stacksjs/security'
+import type { CliOptions as KeyOptions } from '@stacksjs/types'
+import { setEnvValue } from '@stacksjs/utils'
+import { isFile } from '@stacksjs/storage'
+import utf8 from 'crypto-js/enc-utf8'
+import base64 from 'crypto-js/enc-base64'
+
+export async function invoke(options: KeyOptions) {
+  await generate(options)
+}
+
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export async function key(options: KeyOptions) {
+  return invoke(options)
+}
+
+export async function generate(options: KeyOptions) {
+  try {
+    log.info('Setting random application key.')
+
+    if (!isFile('.env'))
+      await runCommand('cp .env.example .env', options)
+      // spawn('cp .env.example .env', { stdio: debug, cwd: projectPath() })
+
+    await setEnvValue('APP_KEY', await generateAppKey())
+    log.success('Application key set')
+
+    return true
+  }
+  catch (error) {
+    log.error('There was an error generating your key.', error)
+    process.exit()
+  }
+}
+
+export async function generateAppKey() {
+  const random = getRandomValues(new Uint8Array(32))
+  const encodedWord = utf8.parse(random.toString())
+  const key = base64.stringify(encodedWord)
+
+  return `base64:${key}`
+}

package/core/actions/src/lint.ts

@@ -0,0 +1,36 @@
+import { log } from '@stacksjs/logging'
+import { intro, outro, runCommand } from '@stacksjs/cli'
+import { runNpmScript } from '@stacksjs/utils'
+import type { LintOptions } from '@stacksjs/types'
+import { ExitCode, NpmScript } from '@stacksjs/types'
+
+export async function invoke(options: LintOptions) {
+  if (options?.fix)
+    await lintFix(options)
+  else
+    await lint(options)
+}
+
+export async function lint(options: LintOptions) {
+  const perf = intro('buddy lint')
+  const result = await runCommand(NpmScript.Lint, { ...options, debug: true })
+
+  if (result.isErr()) {
+    outro('While running `buddy lint`, there was an issue', { startTime: perf, useSeconds: true, isError: true })
+    process.exit(ExitCode.FatalError)
+  }
+
+  outro('Linted', { startTime: perf, useSeconds: true })
+}
+
+export async function lintFix(options?: LintOptions) {
+  log.info('Fixing lint errors...')
+  const result = await runNpmScript(NpmScript.LintFix, options)
+
+  if (result.isErr()) {
+    log.error('There was an error lint fixing your code.', result.error)
+    process.exit()
+  }
+
+  log.success('Fixed lint errors')
+}

package/core/actions/src/make.ts

@@ -0,0 +1,249 @@
+import { italic, log, spawn } from '@stacksjs/cli'
+import { writeTextFile } from '@stacksjs/storage'
+import { resolve } from '@stacksjs/path'
+import type { MakeOptions } from '@stacksjs/types'
+
+export async function invoke(options: MakeOptions) {
+  if (options.component)
+    await component(options)
+
+  if (options.database)
+    await database(options)
+
+  if (options.factory)
+    await factory(options)
+
+  if (options.function)
+    await fx(options)
+
+  if (options.language)
+    await language(options)
+
+  if (options.migration)
+    await migration(options)
+
+  if (options.notification)
+    await notification(options)
+
+  if (options.page)
+    await page(options)
+
+  if (options.stack)
+    await stack(options)
+}
+
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export async function make(options: MakeOptions) {
+  return invoke(options)
+}
+
+export async function component(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}.vue`,
+    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 async function database(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} database...`)
+    await createDatabase(options)
+    log.success(`Created ${italic(name)} database`)
+  }
+  catch (error) {
+    log.error('There was an error creating your database.', error)
+    process.exit()
+  }
+}
+
+export async function createDatabase(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export async function factory(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} factory...`)
+    await createDatabase(options)
+    log.success(`Created ${italic(name)} factory`)
+  }
+  catch (error) {
+    log.error('There was an error creating your factory.', error)
+    process.exit()
+  }
+}
+
+export async function createFactory(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export async function migration(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info(`Creating your ${italic(name)} migration...`)
+    await createMigration(options)
+    log.success(`Created ${italic(name)} migration`)
+  }
+  catch (error) {
+    log.error('There was an error creating your migration.', error)
+    process.exit()
+  }
+}
+
+export async function createMigration(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export async function notification(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 createNotification(options: MakeOptions) {
+  // eslint-disable-next-line no-console
+  console.log('options', options) // wip
+}
+
+export async function page(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your page...')
+    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}.vue`,
+    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 fx(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 language(options: MakeOptions) {
+  try {
+    const name = options.name
+    log.info('Creating your translation file...')
+    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 async function stack(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} && pnpm install`)
+  }
+  catch (error) {
+    log.error('There was an error creating your stack.', error)
+    process.exit()
+  }
+}

package/core/actions/src/preinstall.ts

@@ -0,0 +1,27 @@
+import { log, spawn } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+import type { PreinstallOptions } from '@stacksjs/types'
+import { determineDebugMode } from '@stacksjs/config'
+
+export async function invoke(options?: PreinstallOptions) {
+  try {
+    const stdio = determineDebugMode(options) ? 'inherit' : 'ignore'
+
+    log.info('Preinstall check...')
+    await spawn('npx only-allow pnpm', { stdio, cwd: projectPath() })
+    log.success('Environment ready')
+  }
+  catch (error) {
+    log.error('There was an error pre-installing your stack.', error)
+    process.exit()
+  }
+}
+
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export async function preinstall(options: PreinstallOptions) {
+  return invoke(options)
+}

package/core/actions/src/prepublish.ts

@@ -0,0 +1,16 @@
+import { log } from '@stacksjs/logging'
+import { runtimePath } from '@stacksjs/path'
+import { runNpmScript } from '@stacksjs/utils'
+import { NpmScript } from '@stacksjs/types'
+
+log.info('Running prepublish command...')
+
+// right before we publish, we need to build Stacks
+const result = await runNpmScript(NpmScript.BuildStacks, { debug: true, cwd: runtimePath() }) // TODO: add flag for debug mode
+
+if (result.isErr()) {
+  log.error('There was an error while prepublishing your stack, during the process of building Stacks.', result.error)
+  process.exit()
+}
+
+log.success('Prepublishing completed')

package/core/actions/src/release.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { frameworkPath } from '@stacksjs/path'
+import { runAction } from '@stacksjs/actions'
+import { runNpmScript } from '@stacksjs/utils'
+import { NpmScript } from '@stacksjs/types'
+import { log } from '@stacksjs/cli'
+
+// first, lets generate the package.json's
+let result = await runAction('generate-package-json')
+
+if (result.isErr()) {
+  log.error('There was an error while releasing your stack, during the process of fixing your lint errors.', result.error)
+  process.exit()
+}
+
+// next, lets run lint:fix to make sure there are no lint errors
+// because when "generate-package-json" runs, it generates some lint errors
+result = await runNpmScript(NpmScript.LintFix, { debug: true, cwd: frameworkPath() })
+
+if (result.isErr()) {
+  log.error('There was an error while releasing your stack, during the process of fixing your lint errors.', result.error)
+  process.exit()
+}
+
+// next, lets run the release script to bump the versions and generate the changelog, and push the changes
+// ultimately, a successful git push will trigger the CI/CD release workflow
+result = await runNpmScript(NpmScript.Release, { debug: true, cwd: frameworkPath() })
+
+if (result.isErr()) {
+  log.error('There was an error while releasing your stack.', result.error)
+  process.exit()
+}

package/core/actions/src/test.ts

@@ -0,0 +1,61 @@
+import type { TestOptions } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/types'
+import { intro, outro, runCommand } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+
+export async function invoke(options: TestOptions) {
+  const perf = intro('buddy test')
+  const result = await runCommand(NpmScript.Test, { ...options, debug: true, cwd: projectPath() })
+
+  if (result.isErr()) {
+    outro('While running `buddy test`, there was an issue', { startTime: perf, useSeconds: true, isError: true }, result.error)
+    process.exit()
+  }
+
+  outro('Finished running tests', { startTime: perf, useSeconds: true })
+}
+
+export async function testUi(options: TestOptions) {
+  const perf = intro('buddy test:ui')
+  const result = await runCommand(NpmScript.TestUi, { ...options, debug: true })
+
+  if (result.isErr()) {
+    outro('While running `buddy test:ui`, there was an issue', { startTime: perf, useSeconds: true, isError: true }, result.error)
+    process.exit()
+  }
+}
+
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export async function test(options: TestOptions) {
+  return invoke(options)
+}
+
+export async function typecheck(options: TestOptions) {
+  const perf = intro('buddy test:types')
+  const result = await runCommand(NpmScript.TestTypes, options)
+
+  if (result.isErr()) {
+    outro('While running `buddy test:types`, there was an issue', { startTime: perf, useSeconds: true, isError: true }, result.error)
+    process.exit()
+  }
+
+  outro('Finished typecheck', { startTime: perf, useSeconds: true })
+  process.exit()
+}
+
+export async function testCoverageReport(options: TestOptions) {
+  const perf = intro('buddy test:coverage')
+  const result = await runCommand(NpmScript.TestCoverage, options)
+
+  if (result.isErr()) {
+    outro('While running `buddy test:coverage`, there was an issue', { startTime: perf, useSeconds: true, isError: true }, result.error)
+    process.exit()
+  }
+
+  outro('Generated the test coverage report', { startTime: perf, useSeconds: true })
+  process.exit()
+}

package/core/actions/src/types.ts

@@ -0,0 +1,23 @@
+import { log } from '@stacksjs/logging'
+import { runNpmScript } from '@stacksjs/utils'
+import { NpmScript, type TypesOptions } from '@stacksjs/types'
+
+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')
+}
+
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export async function types(options: TypesOptions) {
+  return invoke(options)
+}