@stacksjs/actions 0.58.48 → 0.58.49

package/src/helpers/component-meta.ts

@@ -0,0 +1,93 @@
+import { frameworkPath, join, parse, projectPath } from '@stacksjs/path'
+import { existsSync, glob, mkdirSync, writeFileSync } from '@stacksjs/storage'
+import MarkdownIt from 'markdown-it'
+import { type ComponentMeta, type MetaCheckerOptions, createComponentMetaChecker } from 'vue-component-meta'
+
+/**
+ * ℹ️ Useful Links
+ *
+ * vue-component-meta tests: https://github.com/johnsoncodehk/volar/blob/master/vue-language-tools/vue-component-meta/tests/index.spec.ts
+ * Discord thread about improving vue-component-meta: https://discord.com/channels/793943652350427136/1027819645677350912
+ * GitHub issue for improving vue-component-meta based on runtime/dynamic props: https://github.com/johnsoncodehk/volar/issues/1854
+ * Discord chat: https://discord.com/channels/793943652350427136/1027819645677350912
+ * original script: https://raw.githubusercontent.com/jd-solanki/anu/main/scripts/gen-component-meta.ts
+ */
+
+export function generateComponentMeta() {
+  const md = new MarkdownIt()
+  const checkerOptions: MetaCheckerOptions = {
+    forceUseTs: true,
+    schema: { ignore: ['MyIgnoredNestedProps'] },
+    printer: { newLine: 1 },
+  }
+
+  const tsconfigChecker = createComponentMetaChecker(
+    projectPath('tsconfig.json'),
+    checkerOptions,
+  )
+
+  const filterMeta = (meta: ComponentMeta): ComponentApi => {
+    // const clonedMeta: ComponentMeta = JSON.parse(JSON.stringify(meta))
+
+    // Exclude global props
+    const props: ComponentApiProps[] = []
+    meta.props.forEach((prop) => {
+      if (prop?.global)
+        return
+
+      const { name, description, required, type, default: defaultValue } = prop
+
+      props.push({
+        name: `${name}${required ? '' : '?'}`,
+        description: md.render(description),
+
+        // required,
+
+        type,
+        default: defaultValue || 'unknown',
+      })
+    })
+
+    return {
+      props,
+      events: meta.events,
+      slots: meta.slots,
+    }
+  }
+
+  const components = glob.sync(['components/*.stx', 'components/**/*.stx'], {
+    cwd: projectPath(),
+    absolute: true,
+  })
+
+  components.forEach((componentPath) => {
+    // Thanks: https://futurestud.io/tutorials/node-js-get-a-file-name-with-or-without-extension
+    const componentExportName = parse(componentPath).name
+    const meta = filterMeta(tsconfigChecker.getComponentMeta(componentPath, componentExportName))
+
+    const metaDirPath = frameworkPath('component-meta')
+
+    // if meta dir doesn't exist create
+
+    if (!existsSync(metaDirPath))
+      mkdirSync(metaDirPath)
+
+    const metaJsonFilePath = join(metaDirPath, `${componentExportName}.json`)
+    writeFileSync(metaJsonFilePath, JSON.stringify(meta, null, 4))
+  })
+}
+
+export interface ComponentApiProps {
+  name: ComponentMeta['props'][number]['name']
+  description: ComponentMeta['props'][number]['description']
+
+  // required: ComponentMeta['props'][number]['required']
+  type: ComponentMeta['props'][number]['type']
+  default: ComponentMeta['props'][number]['default']
+}
+
+export interface ComponentApi {
+  props: ComponentApiProps[]
+  events: ComponentMeta['events']
+  slots: ComponentMeta['slots']
+}

package/src/helpers/index.ts

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

package/src/helpers/lib-entries.ts

@@ -0,0 +1,139 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { kebabCase } from '@stacksjs/strings'
+import type { LibraryType } from '@stacksjs/path'
+import { componentsPath, functionsPath, libraryEntryPath } from '@stacksjs/path'
+import { writeTextFile } from '@stacksjs/storage'
+import { determineResetPreset } from '@stacksjs/utils'
+import { ExitCode } from '@stacksjs/types'
+import library from '~/config/library'
+
+/**
+ * Based on the config values, this method
+ * will generate the library entry points.
+ *
+ * @param type LibraryType
+ */
+export async function generateLibEntry(type: LibraryType) {
+  await createLibraryEntryPoint(type)
+}
+
+export async function createLibraryEntryPoint(type: LibraryType) {
+  if (type === 'vue-components')
+    await createVueLibraryEntryPoint()
+
+  if (type === 'web-components')
+    await createWebComponentLibraryEntryPoint()
+
+  if (type === 'functions')
+    await createFunctionLibraryEntryPoint()
+}
+
+export async function createVueLibraryEntryPoint(type: LibraryType = 'vue-components') {
+  log.info('Creating Vue Component Library Entry Point...')
+
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type),
+  }).catch((err) => {
+    log.error('There was an error generating the Vue Component Library Entry Point.', err)
+    process.exit(ExitCode.FatalError)
+  })
+
+  log.success('Created Vue Component Library Entry Point')
+}
+
+export async function createWebComponentLibraryEntryPoint(type: LibraryType = 'web-components') {
+  log.info('Creating Web Component Library Entry Point...')
+
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type),
+  }).catch((err) => {
+    log.error('There was an error generating the Web Component library entry point', err)
+    process.exit(ExitCode.FatalError)
+  })
+
+  log.success('Created Web Component Library Entry Point')
+}
+
+export async function createFunctionLibraryEntryPoint(type: LibraryType = 'functions') {
+  log.info('Creating Function Library Entry Point...')
+
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type),
+  }).catch((err) => {
+    log.error('There was an error generating Function Library Entry Point', err)
+    process.exit(ExitCode.FatalError)
+  })
+
+  log.success('Created Functions Library Entry Point')
+}
+
+export function generateEntryPointData(type: LibraryType): string {
+  let arr = []
+
+  if (type === 'functions') {
+    if (!library.functions?.functions) {
+      log.error(new Error('There are no functions defined to be built. Please check your config/library.ts file for potential adjustments'))
+      process.exit()
+    }
+
+    for (const fx of library.functions?.functions) {
+      if (Array.isArray(fx))
+        arr.push(`export * as ${fx[1]} from '${functionsPath(fx[0])}'`)
+      else
+        arr.push(`export * from '${functionsPath(fx)}'`)
+    }
+
+    // join the array into a string with each element being on a new line
+    return arr.join('\r\n')
+  }
+
+  if (type === 'vue-components') {
+    if (!library.vueComponents?.tags) {
+      log.error(new Error('There are no components defined to be built. Please check your config/library.ts file for potential adjustments'))
+      process.exit()
+    }
+
+    arr = determineResetPreset()
+
+    for (const component of library.vueComponents?.tags.map(tag => tag.name)) {
+      if (Array.isArray(component))
+        arr.push(`export { default as ${component[1]} } from '${componentsPath(component[0])}.stx'`)
+      else
+        arr.push(`export { default as ${component} } from '${componentsPath(component)}.stx'`)
+    }
+
+    // join the array into a string with each element being on a new line
+    return arr.join('\r\n')
+  }
+
+  // at this point, we know it is a Web Component we are building
+  arr = determineResetPreset()
+  const imports = [...arr, 'import { defineCustomElement } from \'vue\'']
+  const declarations = []
+  const definitions = []
+
+  if (!library.webComponents?.tags) {
+    log.error(new Error('There are no components defined to be built. Please check your config/library.ts file for potential adjustments'))
+    process.exit()
+  }
+
+  for (const component of library.webComponents?.tags.map(tag => tag.name)) {
+    if (Array.isArray(component)) {
+      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.stx'`)
+      declarations.push(`const ${component[1]}CustomElement = defineCustomElement(${component[1]})`)
+      definitions.push(`customElements.define('${kebabCase(component[1])}', ${component[1]}CustomElement)`)
+    }
+    else {
+      imports.push(`import ${component} from '${componentsPath(component)}.stx'`)
+      declarations.push(`const ${component}CustomElement = defineCustomElement(${component})`)
+      definitions.push(`customElements.define('${kebabCase(component)}', ${component}CustomElement)`)
+    }
+  }
+
+  // join the array into a string with each element being on a new line
+  return [...imports, ...declarations, ...definitions].join('\r\n')
+}

package/src/helpers/package-json.ts

@@ -0,0 +1,96 @@
+import { log } from '@stacksjs/logging'
+import { writeTextFile } from '@stacksjs/storage'
+import { packageJsonPath } from '@stacksjs/path'
+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
+
+  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": "bun",
+  "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": "bun --bun 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 file`)
+  }
+  catch (err) {
+    log.error(`There was an error creating the ${prettyName} package.json`, err)
+  }
+}

package/src/helpers/utils.ts

@@ -0,0 +1,82 @@
+import * as storage from '@stacksjs/storage'
+import { italic, runCommand, runCommands, underline } from '@stacksjs/cli'
+import { log } from '@stacksjs/logging'
+import * as p from '@stacksjs/path'
+import type { ActionOptions, StacksError, Subprocess } from '@stacksjs/types'
+import { type Result, err, handleError } from '@stacksjs/error-handling'
+
+function parseOptions(options?: ActionOptions) {
+  if (!options)
+    return ''
+
+  const parsedOptions = Object.entries(options).map(([key, value]) => {
+    if (key.length === 1)
+      return `-${key}=${value}`
+
+    if (typeof value === 'boolean' && value) // if the value is `true`, just return the key
+      return `--${key}`
+
+    return `--${key}=${typeof value === 'string' && value.includes(' ') ? `"${value}"` : value}`
+  })
+
+  // filter out undefined values and join the array
+  return parsedOptions.filter(Boolean).join(' ').replace('----=', '')
+}
+
+// export type ActionResult = CommandResult
+
+/**
+ * Run an Action the Stacks way.
+ *
+ * @param action 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?: ActionOptions): Promise<Result<Subprocess, StacksError>> {
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`))
+
+  const opts = parseOptions(options)
+  const path = p.relativeActionsPath(`${action}.ts`)
+  const cmd = `bun --bun ${`${path} ${opts}`}`
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options,
+  }
+
+  if (options?.verbose) {
+    log.debug('Running cmd:', underline(italic(cmd)))
+    log.debug('Running action:', underline(italic(`./actions/${action}.ts`)))
+    log.debug('with action options of:', o)
+  }
+
+  return await runCommand(cmd, o)
+}
+
+/**
+ * Run Actions the Stacks way.
+ *
+ * @param actions The actions to invoke.
+ * @param options The options to pass to the command.
+ * @returns The result of the command.
+ */
+export async function runActions(actions: string[], options?: ActionOptions) {
+  if (!actions.length)
+    return err('No actions were specified')
+
+  for (const action of actions) {
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`)
+  }
+
+  const commands = actions.map(action => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`)
+
+  return await runCommands(commands, options)
+}
+
+export function hasAction(action: string) {
+  if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
+    return true
+
+  return storage.isFile(p.actionsPath(`${action}.ts`))
+}

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

@@ -0,0 +1,35 @@
+import { log } from '@stacksjs/logging'
+import { customElementsDataPath } from '@stacksjs/path'
+import { writeTextFile } from '@stacksjs/storage'
+import library from '~/config/library'
+
+export async function generateVsCodeCustomData() {
+  try {
+    log.info('Generating custom-elements.json...')
+    // the version does not have to be set here,
+    // it will be set automatically by the release script
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData(),
+    })
+    log.success('Generated custom-elements.json for IDEs.')
+  }
+  catch (err) {
+    log.error('There was an error generating the custom-elements.json file.', err)
+  }
+}
+
+export async function generateWebTypes() {
+  log.info('Generating web-types.json...')
+  log.info('This feature is not yet implemented.')
+}
+
+function generateComponentInfoData() {
+  const componentsData = JSON.stringify(library.vueComponents?.tags)
+
+  return `{
+  "version": 1.1,
+  "tags": ${componentsData}
+}
+`
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export * from './action'
+export * from './dev'
+export * from './generate'
+export * from './helpers'
+
+export { examples as runExample } from './examples'
+export { commit as runCommit } from './commit'
+export { add as runAdd } from './add'
+
+// makeFactory,
+export {
+  make as runMake,
+  makeComponent,
+  makeDatabase,
+  makeFunction,
+  makeLanguage,
+  makeNotification,
+  makePage,
+  makeStack,
+  createComponent,
+  createDatabase,
+  createFactory,
+  createFunction,
+  createLanguage,
+  createMigration,
+  createModel,
+  createNotification,
+  createPage,
+} from './make'

package/src/key-generate.ts

@@ -0,0 +1,10 @@
+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'
+
+if (!isFile('.env'))
+  await runCommand('cp .env.example .env', { cwd: projectPath() })
+
+await setEnvValue('APP_KEY', generateAppKey())

package/src/lint/fix.ts

@@ -0,0 +1,7 @@
+import { log, runCommands } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+import { NpmScript } from '@stacksjs/enums'
+
+log.info('Ensuring Code Style...')
+await runCommands([NpmScript.LintFix], { cwd: projectPath() })
+log.success('Linted')

package/src/lint/index.ts

@@ -0,0 +1,27 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/enums'
+import { log, runCommands } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+
+// import { $ } from 'bun'
+
+log.info('Ensuring Code Style...')
+
+// TODO: somehow, we currently cannot trigger bunx using $`` syntax
+// $.cwd(projectPath())
+
+// await $`${NpmScript.Lint}`
+// await $`${NpmScript.LintPackageJson}`
+
+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)
+}
+
+log.success('Linted')