@stacksjs/actions 0.58.48 → 0.58.49

package/dist/src/generate/ide-helpers.js

@@ -15,6 +15,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",

package/dist/src/generate/lib-entries.js

@@ -19,6 +19,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",
@@ -155,14 +156,15 @@ function generateEntryPointData(type) {
 
 // src/generate/lib-entries.ts
 import {log as log2} from "@stacksjs/logging";
+import {library as library2} from "@stacksjs/config";
 import {hasComponents, hasFunctions} from "@stacksjs/storage";
-if (hasComponents()) {
+if (library2.releaseable && hasComponents()) {
   await generateLibEntry("vue-components");
   await generateLibEntry("web-components");
 } else {
   log2.info("No components found. Skipping building component entry points.");
 }
-if (hasFunctions())
+if (library2.releaseable && hasFunctions())
   await generateLibEntry("functions");
 else
   log2.info("No functions found. Skipping building function entry point.");

package/dist/src/generate/vscode-custom-data.js

@@ -15,6 +15,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",

package/dist/src/helpers/lib-entries.js

@@ -17,6 +17,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",

package/dist/src/helpers/package-json.js

@@ -13,6 +13,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",

package/dist/src/helpers/vscode-custom-data.js

@@ -13,6 +13,7 @@ var library_default = {
   author: "Chris Breuer",
   contributors: ["Chris Breuer <chris@stacksjs.org>"],
   defaultLanguage: "en",
+  releaseable: true,
   vueComponents: {
     name: "hello-world-vue",
     description: "Your Vue component library description",

package/dist/src/upgrade.js

@@ -6,7 +6,7 @@ import {log} from "@stacksjs/logging";
 import {projectPath} from "@stacksjs/path";
 import * as storage from "@stacksjs/storage";
 // package.json
-var version = "0.58.48";
+var version = "0.58.49";
 
 // src/upgrade.ts
 function checkForUncommittedChanges(options2) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/actions",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -41,7 +41,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/action.ts

@@ -0,0 +1,11 @@
+export class Action {
+  name: string
+  description: string
+  handle: () => Promise<string>
+
+  constructor({ name, description, handle }: { name: string, description: string, handle: () => Promise<string> }) {
+    this.name = name
+    this.description = description
+    this.handle = handle
+  }
+}

package/src/actions.ts

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

package/src/add.ts

@@ -0,0 +1,27 @@
+import { installPackage } from '@stacksjs/cli'
+import type { AddOptions } from '@stacksjs/types'
+
+export async function invoke(options: AddOptions) {
+  if (options?.table)
+    await addTable()
+
+  if (options?.calendar)
+    await addCalendar()
+}
+
+export async function add(options: AddOptions) {
+  return invoke(options)
+}
+
+export async function addTable() {
+  await installPackage('@stacksjs/table')
+}
+
+export async function addCalendar() {
+  await installPackage('@stacksjs/calendar')
+}
+
+export async function installPackages(names: string[]) {
+  for (const name of names)
+    await installPackage(name)
+}

package/src/ai/request-model-access.ts

@@ -0,0 +1,74 @@
+import process from 'node:process'
+import * as AWS4 from 'aws4'
+
+// todo: Remove axios and use the AWS SDK instead if possible, but I couldn't get it to work. At least, move to our own fetch wrapper
+import axios from 'axios'
+import { config } from 'aws-sdk'
+import { log } from '@stacksjs/cli'
+import { ai } from '@stacksjs/config'
+
+// Specify the AWS profile
+// process.env.AWS_PROFILE = 'your-profile-name' -> no need to define this because of our .env file
+process.env.AWS_REGION = 'us-east-1'
+
+config.getCredentials((err) => {
+  if (err) {
+    log.info(err.stack)
+  }
+  else if (config.credentials) {
+    const { accessKeyId, secretAccessKey, sessionToken } = config.credentials
+    log.info('AWS credentials are set', accessKeyId, secretAccessKey, sessionToken)
+
+    const endpoint = 'https://bedrock.us-east-1.amazonaws.com/foundation-model-entitlement'
+    const region = 'us-east-1'
+    const service = 'bedrock'
+
+    const models = ai.models
+
+    if (!models) {
+      log.error('No AI models found. Please set ./config/ai.ts values.')
+      return
+    }
+
+    for (const model of models) {
+      log.info(`Requesting access to model ${model}`)
+      const request = {
+        host: 'bedrock.us-east-1.amazonaws.com',
+        method: 'POST',
+        url: endpoint,
+        path: '/foundation-model-entitlement',
+        headers: {
+          'Content-Type': 'application/json',
+          'authority': 'http://bedrock.us-east-1.amazonaws.com',
+        },
+        body: JSON.stringify({ modelId: model }), // use the current model in the loop
+        service,
+        region,
+      }
+
+      // Sign the request
+      const signedRequest = AWS4.sign(request, { accessKeyId, secretAccessKey, sessionToken })
+
+      // Convert headers to the correct type
+      const axiosHeaders = Object.fromEntries(
+        Object.entries(signedRequest.headers || {}).map(([key, value]) => [key, String(value)]),
+      )
+
+      const url = `https://${signedRequest.host}${signedRequest.path}`
+
+      // Send the request
+      axios({
+        method: signedRequest.method,
+        url,
+        headers: axiosHeaders,
+        data: signedRequest.body,
+      })
+        .then((response) => {
+          log.info(response.data)
+        })
+        .catch((error) => {
+          log.error(error.data)
+        })
+    }
+  }
+})

package/src/build/cli.ts

@@ -0,0 +1,7 @@
+import { log } from '@stacksjs/cli'
+import { buddyPath } from '@stacksjs/path'
+import { $ } from 'bun'
+
+log.info('Building CLI')
+
+await $`bun ${buddyPath('compile.ts')}`

package/src/build/component-libs.ts

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

package/src/build/core.ts

@@ -0,0 +1,34 @@
+import process from 'node:process'
+import { glob } from '@stacksjs/storage'
+import { dim, italic, log } from '@stacksjs/cli'
+import { corePath } from '@stacksjs/path'
+import { ExitCode } from '@stacksjs/types'
+import { $ } from 'bun'
+
+log.info('Building core packages')
+
+const dirs = (await glob([corePath('*')], { onlyDirectories: true })).sort()
+
+if (dirs.length === 0) {
+  log.info('No core packages found')
+  process.exit(ExitCode.FatalError)
+}
+
+for (const folder of dirs) {
+  log.info(`🏗️  Building ${italic(dim(folder))}`)
+
+  $.cwd(folder)
+  await $`bun run build`
+  log.success(`${italic(dim(folder))} built`)
+
+  // eslint-disable-next-line no-console
+  console.log(``)
+}
+
+// dirs.forEach(async (folder) => {
+//   log.info(`🏗️  Building ${italic(dim(folder))}`)
+
+//   $.cwd(folder)
+//   const text = await $`bun run build`.text()
+//   console.log(text)
+// })

package/src/build/desktop.ts

@@ -0,0 +1,7 @@
+import { runCommand } from '@stacksjs/cli'
+import { corePath } from '@stacksjs/path'
+
+await runCommand('bun run build:app', {
+  // ...options,
+  cwd: corePath('desktop'),
+})

package/src/build/docs.ts

@@ -0,0 +1,7 @@
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand('bun run build', {
+  // ...options,
+  cwd: frameworkPath('docs'),
+})

package/src/build/stacks.ts

@@ -0,0 +1,7 @@
+import { frameworkPath } from '@stacksjs/path'
+import { runCommands } from '@stacksjs/cli'
+
+await runCommands([
+  'bun build:cli', // command to build the Buddy CLI
+  'bun build:core', // command to build the Stacks Core
+], { verbose: true, cwd: frameworkPath() })

package/src/build.ts

@@ -0,0 +1,89 @@
+import { log } from '@stacksjs/logging'
+import { hasComponents, hasFunctions } from '@stacksjs/storage'
+import { runNpmScript } from '@stacksjs/utils'
+import type { BuildOptions } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/enums'
+import { generateTypes } from './generate'
+
+export async function invoke(options: BuildOptions) {
+  if (options.components)
+    await componentLibraries(options)
+
+  else if (options.vueComponents)
+    await vueComponentLibrary(options)
+
+  else if (options.webComponents || options.elements)
+    await webComponentLibrary(options)
+
+  else if (options.functions)
+    await functionsLibrary(options)
+
+  else if (options.docs)
+    await docs(options)
+
+  else if (options.stacks)
+    await stacks(options)
+
+  await generateTypes()
+}
+
+export async function build(options: BuildOptions) {
+  return invoke(options)
+}
+
+export async function componentLibraries(options: BuildOptions) {
+  await runNpmScript(NpmScript.GenerateEntries, options)
+  await vueComponentLibrary(options)
+  await webComponentLibrary(options)
+}
+
+export async function vueComponentLibrary(options: BuildOptions) {
+  if (hasComponents()) {
+    log.info('Building your component library...')
+    await runNpmScript(NpmScript.BuildComponents, options)
+    log.success('Your component library was built successfully')
+  }
+  else {
+    // todo: throw custom error here
+    log.warn('No components found.')
+    log.info('Before you can build components,')
+    log.info('you need to have created some in the ./components folder.')
+  }
+}
+
+export async function webComponentLibrary(options: BuildOptions) {
+  log.info('Building your component library for production use & npm/CDN distribution...')
+
+  if (hasComponents()) {
+    await runNpmScript(NpmScript.BuildWebComponents, options)
+    log.success('Your Web Component library was built successfully')
+  }
+  else {
+    // todo: throw custom error here
+    log.info('No components found.')
+  }
+}
+
+export async function docs(options: BuildOptions) {
+  log.info('Building the documentation site...')
+  await runNpmScript(NpmScript.BuildDocs, options)
+  log.success('Docs built successfully')
+}
+
+export async function stacks(options: BuildOptions) {
+  log.info('Building the Stacks Framework...')
+  await runNpmScript(NpmScript.BuildStacks, options)
+  log.success('Stacks built successfully')
+}
+
+export async function functionsLibrary(options: BuildOptions) {
+  if (hasFunctions()) {
+    log.info('Building your functions library for production usages...')
+    log.info('Production usages include: manual npm distribution and/or CDN distribution')
+    await runNpmScript(NpmScript.BuildFunctions, options)
+    log.success('Functions library built successfully')
+  }
+  else {
+    log.info('No functions found')
+  }
+}

package/src/bump.ts

@@ -0,0 +1,11 @@
+import { runCommand } from '@stacksjs/cli'
+import { path as p } from '@stacksjs/path'
+
+await runCommand('buddy changelog --quiet', {
+  cwd: p.projectPath(),
+})
+
+await runCommand(
+  'bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all',
+  { cwd: p.frameworkPath(), stdin: 'inherit' },
+)

package/src/cdn/invalidate-cache.ts

@@ -0,0 +1,27 @@
+// TODO: port over logic from meemalabs/cloudfront to invalidate cache
+// buddy cloud invalidate-cache --paths /index.html /about.html
+
+// import { CloudFrontClient, CreateInvalidationCommand } from '@aws-sdk/client-cloudfront'
+
+// const cloudfront = new CloudFrontClient()
+
+// const params = {
+//   DistributionId: 'YOUR_DISTRIBUTION_ID', /* required */
+//   InvalidationBatch: { /* required */
+//     CallerReference: `${Date.now()}`, /* required */
+//     Paths: { /* required */
+//       Quantity: 1, /* required */
+//       Items: [
+//         '/*',
+//         /* more items */
+//       ],
+//     },
+//   },
+// }
+
+// const command = new CreateInvalidationCommand(params)
+
+// cloudfront.send(command).then(
+//   data => console.log(data),
+//   err => console.log(err, err.stack),
+// )

package/src/changelog.ts

@@ -0,0 +1,11 @@
+import { execSync, runCommand } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+
+const fromRevision = await execSync('git describe --abbrev=0 --tags HEAD^')
+// console.log('fromRevision', fromRevision)
+const toRevision = await execSync('git describe')
+// console.log('toRevision', toRevision)
+
+await runCommand(`bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`, {
+  cwd: projectPath(),
+})

package/src/clean.ts

@@ -0,0 +1,6 @@
+import { log } from '@stacksjs/logging'
+import { clean } from '@stacksjs/utils'
+
+log.info('Running clean command...')
+
+await clean()

package/src/commit.ts

@@ -0,0 +1,14 @@
+import { log } from '@stacksjs/logging'
+import { runNpmScript } from '@stacksjs/utils'
+import type { CleanOptions } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/enums'
+
+export async function invoke(options: CleanOptions) {
+  log.info('Committing...')
+  await runNpmScript(NpmScript.Commit, options)
+  log.success('Committed')
+}
+
+export async function commit(options: CleanOptions) {
+  return invoke(options)
+}

package/src/copy-types.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+
+/**
+ * This action copies all the generated types.
+ */
+
+import { frameworkPath } from '@stacksjs/path'
+import { copyFolder } from '@stacksjs/storage'
+
+// relative to scripts directory
+const destinations = [
+  [frameworkPath('dist/types/components'), frameworkPath('components/vue/dist/types')],
+  [frameworkPath('dist/types/components'), frameworkPath('components/web/dist/types')],
+  [frameworkPath('dist/types/functions'), frameworkPath('functions/dist/types')],
+]
+
+destinations.forEach(([src, dest]) => {
+  // const srcPath = resolve(__filename, '..', src)
+  // const destPath = resolve(__filename, '..', dest)
+
+  copyFolder(src, dest)
+})

package/src/database/fields.ts

@@ -0,0 +1,111 @@
+import User from '../../../../../../app/Models/User'
+
+const fields = User.fields // Assuming you have a specific type for fields
+
+export interface ModelElement {
+  field: string
+  default: string | number | boolean | Date | undefined | null
+  unique: boolean
+  fieldArray: FieldArrayElement[]
+}
+
+export interface FieldArrayElement {
+  entity: string
+  charValue?: string | null
+  // Add other properties as needed
+}
+const rules: string[] = []
+
+async function extractModelRule() {
+  const modelFile = Bun.file('../../../../../app/Models/User.ts') // Assuming Bun is imported properly
+
+  const code = await modelFile.text()
+
+  const regex = /rule:.*$/gm
+
+  let match: RegExpExecArray | null
+  match = regex.exec(code)
+  while (match !== null) {
+    rules.push(match[0])
+    match = regex.exec(code)
+  }
+}
+
+await extractModelRule()
+
+const fieldKeys = Object.keys(fields)
+
+const input: ModelElement[] = fieldKeys.map((field, index) => {
+  const fieldExist = fields[field]
+  let defaultValue = null
+  let uniqueValue = false
+
+  if (fieldExist) {
+    defaultValue = fieldExist?.default || null
+    uniqueValue = fieldExist?.unique || false
+  }
+
+  return {
+    field,
+    default: defaultValue,
+    unique: uniqueValue,
+    fieldArray: parseRule(rules[index]),
+  }
+})
+
+function parseRule(rule: string): FieldArrayElement[] {
+  const parts = rule.split('rule: validator.')
+
+  if (parts.length !== 2)
+    return []
+
+  if (!parts[1])
+    parts[1] = ''
+
+  const extractedString = parts[1].replace(/,/g, '')
+
+  if (!extractedString)
+    return []
+
+  const extractedParts = extractedString.split('.')
+  const regex = /\(([^)]+)\)/
+
+  return extractedParts.map((input) => {
+    const match = regex.exec(input)
+    const value = match ? match[1] : null
+    const field = input.replace(regex, '').replace(/\(|\)/g, '')
+    return { entity: field, charValue: value }
+  })
+}
+
+const modelEntity: ModelElement[] = input
+
+// You can now use the modelEntity array with type safety.
+
+const fieldAssociation: { [key: string]: { [key: string]: string } } = {
+  mysql: {
+    string: 'varchar',
+    enum: 'varchar',
+    number: 'integer',
+    boolean: 'boolean',
+    text: 'text',
+  },
+  sqlite: {
+    string: 'text',
+    enum: 'text',
+    number: 'integer',
+    boolean: 'boolean',
+    text: 'text',
+  },
+}
+
+const fieldEntity = [
+  'maxLength',
+]
+
+const excludeFieldEntity = [
+  'minLength',
+  'enum',
+]
+
+export { fieldEntity, fieldAssociation, modelEntity, excludeFieldEntity }

package/src/database/migration-mysql.ts

@@ -0,0 +1,72 @@
+import User from '../../../../../../app/Models/User'
+import { fieldAssociation, fieldEntity, modelEntity } from './fields'
+
+const file = Bun.file('user-migration.ts')
+
+const driver = 'mysql'
+
+const writer = file.writer()
+
+writer.write('import { Kysely, sql } from \'kysely\'\n')
+writer.write('import { db } from \'@stacksjs/database\'\n')
+writer.write('\n')
+writer.write('export async function up(db: Kysely<any>): Promise<void> {\n')
+
+writer.write('  await db.schema\n')
+writer.write(`    .createTable('${User.table}')\n`)
+
+writer.write('    .addColumn(\'id\', \'integer\', (col) => col.primaryKey())\n')
+
+for (let modelIndex = 0; modelIndex < modelEntity.length; modelIndex++) {
+  const modelElement = modelEntity[modelIndex]
+
+  if (!modelElement)
+    continue
+
+  let entity = ''
+  let characteristic = ''
+
+  const isNullablePresent = modelElement.fieldArray.some(item => item.entity === 'nullable')
+
+  if (modelElement.default)
+    characteristic += `.defaultTo('${modelElement.default.toString()}')`
+
+  if (modelElement.unique)
+    characteristic += '.unique()'
+
+  if (!isNullablePresent)
+    characteristic += '.notNull()'
+
+  for (let fieldIndex = 0; fieldIndex < modelElement.fieldArray.length; fieldIndex++) {
+    const fieldArrayElement = modelElement.fieldArray[fieldIndex]
+
+    if (!fieldArrayElement)
+      continue
+
+    if (!fieldAssociation[driver])
+      continue
+
+    if (fieldAssociation[driver][fieldArrayElement.entity])
+      entity += `${fieldAssociation[driver][fieldArrayElement.entity]}`
+
+    fieldEntity.forEach((entityField) => {
+      if (fieldArrayElement.entity === entityField)
+        entity += `(${fieldArrayElement.charValue})`
+    })
+
+    const isMaxLengthPresent = modelElement.fieldArray.some(item => item.entity === 'maxLength')
+
+    if (fieldAssociation[driver][fieldArrayElement.entity] === 'varchar' && !isMaxLengthPresent)
+      entity += '(255)'
+  }
+
+  writer.write(`    .addColumn('${modelElement.field}', '${entity}', (col) => col${characteristic})\n`)
+}
+
+writer.write('    .addColumn(\'created_at\', \'timestamp\', (col) => col.defaultTo(sql`now()`).notNull())\n')
+writer.write('    .execute()\n')
+writer.write('}\n\n')
+
+writer.write('process.exit(0)\n')
+
+await writer.end()