@stacksjs/actions 0.58.47 → 0.58.49

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()

package/src/database/migration-sqlite.ts

@@ -0,0 +1,67 @@
+// import { generateMigrationFile } from '@stacksjs/database'
+import User from '../../../../../../app/Models/User'
+import { fieldAssociation, modelEntity } from './fields'
+
+const file = Bun.file('user-migration.ts')
+const writer = file.writer()
+
+const driver = 'sqlite'
+
+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})`
+    // })
+  }
+
+  writer.write(`    .addColumn('${modelElement.field}', '${entity}', (col) => col${characteristic})\n`)
+}
+
+writer.write('    .addColumn(\'created_at\', \'timestamp\', (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull())\n')
+writer.write('    .execute()\n')
+writer.write('}\n\n')
+
+writer.write('process.exit(0)\n')
+
+await writer.end()

package/src/database/migration.ts

@@ -0,0 +1,10 @@
+// import { generateMigrationFile } from '@stacksjs/database'
+// import { config } from '@stacksjs/config'
+
+// const driver = config.database.default
+const driver = 'sqlite'
+
+if (driver === 'sqlite')
+  await import('./migration-sqlite.js')
+else
+  await import('./migration-mysql.js')

package/src/database/seed.ts

@@ -0,0 +1,4 @@
+// import { database } from '@stacksjs/config'
+import { seed } from '@stacksjs/database'
+
+await seed()

package/src/database/user-migration.ts

@@ -0,0 +1,20 @@
+import process from 'node:process'
+import type { Kysely } from 'kysely'
+import { sql } from 'kysely'
+import { db } from '@stacksjs/database'
+import { ExitCode } from '@stacksjs/types'
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('users')
+    .addColumn('id', 'integer', col => col.primaryKey())
+    .addColumn('name', 'text', col => col.defaultTo('test').notNull())
+    .addColumn('email', 'text', col => col.defaultTo('test email').unique().notNull())
+    .addColumn('password', 'text', col => col.notNull())
+    .addColumn('created_at', 'timestamp', col => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull())
+    .execute()
+}
+
+await up(db)
+
+process.exit(ExitCode.Success)

package/src/deploy/create-receipt-rule.ts

@@ -0,0 +1,55 @@
+import process from 'node:process'
+import { log } from '@stacksjs/cli'
+import { S3 } from '@aws-sdk/client-s3'
+import { SES } from '@aws-sdk/client-ses'
+import { ExitCode } from '@stacksjs/types'
+
+const ses = new SES({ apiVersion: '2010-12-01' })
+const s3 = new S3({ apiVersion: '2006-03-01' })
+
+// oddly, this somehow does not play well within a CDK construct
+// so we need to use the AWS SDK directly to create the rule
+// unsure whether it's an AWS or implementation issue
+
+// need to query S3 to get the bucket name, based on whether the name contains -email-
+// which is indicative of the email bucket created by the CDK construct
+let bucketName: string | undefined
+const data = await s3.listBuckets({})
+
+if (data.Buckets)
+  bucketName = data.Buckets.find(bucket => bucket.Name && bucket.Name.includes('-email-'))?.Name
+
+// eslint-disable-next-line no-console
+console.log('Bucket Name:', bucketName)
+
+if (!bucketName) {
+  // eslint-disable-next-line no-console
+  console.log('Stacks Email Bucket not found')
+  process.exit(ExitCode.FatalError)
+}
+
+const params: any = {
+  Rule: {
+    Actions: [
+      {
+        S3Action: {
+          BucketName: bucketName,
+          ObjectKeyPrefix: 'tmp/email_in',
+        },
+      },
+    ],
+    Enabled: true,
+    Name: 'Inbound',
+    ScanEnabled: true,
+    TlsPolicy: 'Require',
+  },
+  RuleSetName: 'your-rule-set-name',
+}
+
+try {
+  const data = await ses.createReceiptRule(params)
+  log.info('Success', data)
+}
+catch (error) {
+  console.error(error)
+}

package/src/deploy/index.ts

@@ -0,0 +1,46 @@
+import process from 'node:process'
+import { log, runCommand } from '@stacksjs/cli'
+import { config } from '@stacksjs/config'
+import { path as p } from '@stacksjs/path'
+import { storage } from '@stacksjs/storage'
+
+await runCommand('bun run build', {
+  cwd: p.frameworkPath(),
+})
+
+if (storage.hasFiles(p.projectPath('docs'))) {
+  await runCommand('bun run build', {
+    cwd: p.frameworkPath('docs'),
+  })
+}
+
+if (config.app.docMode !== true) { // when in docs mode, we disregard building views
+  await runCommand('bun run build', {
+    cwd: p.frameworkPath('views'),
+  })
+}
+
+// await runCommand('bun run build-layer', {
+//   cwd: p.corePath('cloud'),
+// })
+
+// await runCommand('bun run build-edge', {
+//   cwd: p.corePath('cloud'),
+// })
+
+await runCommand('bun zip/api.ts', {
+  cwd: p.actionsPath(),
+})
+
+await runCommand('bun zip.ts', {
+  cwd: p.cloudPath(),
+})
+
+log.info('Preparing Deployment...')
+
+const profile = process.env.AWS_PROFILE || 'stacks'
+
+// TODO: ensure we check whether cdk bootstrap needs to be run
+await runCommand(`bunx cdk deploy --require-approval never --profile="${profile}"`, {
+  cwd: p.cloudPath(),
+})

package/src/dev/api.ts

@@ -0,0 +1,19 @@
+import { path as p } from '@stacksjs/path'
+import { log, parseOptions, runCommand } from '@stacksjs/cli'
+import { serve } from '@stacksjs/router'
+import { config } from '@stacksjs/config'
+
+const options = parseOptions()
+
+if (options.verbose)
+  log.info('Running API dev server via', `bunx vite --config ${p.vitePath('src/api.ts')}`, options)
+
+serve({
+  port: config.app.ports?.api, // defaults to 3999
+})
+
+// the reason we start a Vite dev server next is because we need the Bun server proxied by vite
+await runCommand(`bunx vite --config ${p.vitePath('src/api.ts')}`, {
+  // ...options,
+  cwd: p.frameworkPath(),
+})

package/src/dev/components.ts

@@ -0,0 +1,14 @@
+import { frameworkPath, vitePath } from '@stacksjs/path'
+import { parseOptions, runCommand } from '@stacksjs/cli'
+import type { DeployOptions } from '@stacksjs/types'
+
+const options: DeployOptions = parseOptions()
+
+if (options.verbose)
+// eslint-disable-next-line no-console
+  console.log('dev components options', options)
+
+await runCommand(`bunx vite --config ${vitePath('src/components.ts')}`, {
+  ...options,
+  cwd: frameworkPath(),
+})

package/src/dev/dashboard.ts

@@ -0,0 +1,7 @@
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand('bun run dev', {
+  cwd: frameworkPath('views/dashboard'),
+  // verbose: true,
+})

package/src/dev/desktop.ts

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

package/src/dev/docs.ts

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

package/src/dev/index.ts

@@ -0,0 +1,48 @@
+import { log } from '@stacksjs/logging'
+import type { DevOptions } from '@stacksjs/types'
+import { Action } from '@stacksjs/enums'
+import { runAction } from '../helpers'
+
+export async function runDevServer(options: DevOptions) {
+  log.info('Starting your Frontend Engine...')
+  await runAction(Action.Dev, options)
+}
+
+export async function runFrontendDevServer(options: DevOptions) {
+  log.info('Starting your UI Engine...')
+  await runAction(Action.Dev, options)
+}
+
+export async function runBackendDevServer(options: DevOptions) {
+  runApiDevServer(options)
+}
+
+export async function runApiDevServer(options: DevOptions) {
+  log.info('Starting your API...')
+  await runAction(Action.DevApi, options)
+}
+
+export async function runComponentsDevServer(options: DevOptions) {
+  log.info('Starting your Library Engine...')
+  await runAction(Action.DevComponents, options)
+}
+
+export async function runDashboardDevServer(options: DevOptions) {
+  log.info('Starting your Dashboard...')
+  await runAction(Action.DevDashboard, options)
+}
+
+export async function runSystemTrayDevServer(options: DevOptions) {
+  log.info('Starting your System Tray...')
+  await runAction(Action.DevSystemTray, options)
+}
+
+export async function runDesktopDevServer(options: DevOptions) {
+  log.info('Starting your Desktop Engine...')
+  await runAction(Action.DevDesktop, options)
+}
+
+export async function runDocsDevServer(options: DevOptions) {
+  log.info('Starting your Docs Engine...')
+  await runAction(Action.DevDocs, options)
+}

package/src/dev/system-tray.ts

@@ -0,0 +1,6 @@
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand('bun run dev', {
+  cwd: frameworkPath('system-tray'),
+})

package/src/dev/views.ts

@@ -0,0 +1,7 @@
+import { runCommand } from '@stacksjs/cli'
+import { frameworkPath } from '@stacksjs/path'
+
+await runCommand('bun run dev', {
+  cwd: frameworkPath('views/web'),
+  // verbose: true,
+})

package/src/domains/add.ts

@@ -0,0 +1,82 @@
+import process from 'node:process'
+import { createHostedZone, getNameservers, updateNameservers } from '@stacksjs/dns'
+import { app } from '@stacksjs/config'
+import { handleError } from '@stacksjs/error-handling'
+import { italic, parseOptions, runCommand } from '@stacksjs/cli'
+import { whois } from '@stacksjs/whois'
+import { logger } from '@stacksjs/logging'
+import { projectConfigPath } from '@stacksjs/path'
+
+interface AddOptions {
+  domain?: string
+  verbose: boolean
+}
+
+const parsedOptions = parseOptions()
+const options: AddOptions = {
+  domain: parsedOptions.domain as string,
+  verbose: parsedOptions.verbose as boolean,
+}
+
+if (!options.domain) {
+  if (app.url) {
+    options.domain = app.url
+  }
+  else {
+    handleError('there was no domain provided when')
+    process.exit(1)
+  }
+}
+
+const result = await createHostedZone(options.domain)
+
+if (result.isErr()) {
+  handleError(result.error)
+  process.exit(1)
+}
+
+// Update the nameservers
+const nameServers = await getNameservers(options.domain)
+
+if (!nameServers) {
+  handleError(`No nameservers found for domain: ${options.domain}. Please ensure the Hosted Zone exists in Route53.`)
+  process.exit(1)
+}
+
+await updateNameservers(nameServers)
+
+const nameservers = result.value
+const registrar: string = (await whois(options.domain, true)).parsedData.Registrar
+
+// usually for Route53 registered domains, we don't need to update create a hosted zone as it's already
+// done for us. But in case it's not, we still need to ensure it's created before we can deploy
+if (registrar.includes('Amazon')) {
+  if (parsedOptions.deploy) {
+    await runCommand('buddy deploy')
+  }
+  else {
+    logger.log('')
+    logger.log('You can now continue your deployment process by re-running:')
+    logger.log('')
+    logger.log(`  ➡️  ${italic('buddy deploy')}`)
+    logger.log('')
+  }
+  process.exit(0)
+}
+
+logger.log('')
+logger.log('ℹ️  Please note, before continuing your deployment process,')
+logger.log(`   update your ${registrar} nameservers to the following:`)
+
+const emojis = ['1️⃣', '2️⃣', '3️⃣', '4️⃣']
+logger.log('')
+nameservers.forEach((nameserver, index) => {
+  logger.log(`  ${emojis[index]}  Nameserver: ${nameserver}`)
+})
+logger.log('')
+logger.log(italic(`stored in ${projectConfigPath('dns.ts')}`))
+logger.log('')
+logger.log('Once the nameservers have been updated, re-run the following command:')
+logger.log('')
+logger.log(`  ➡️  ${italic('buddy deploy')}`)
+logger.log('')

package/src/domains/purchase.ts

@@ -0,0 +1,76 @@
+import process from 'node:process'
+import { log, parseOptions } from '@stacksjs/cli'
+import type { PurchaseOptions } from '@stacksjs/cloud'
+import { purchaseDomain } from '@stacksjs/cloud'
+import { config } from '@stacksjs/config'
+import { handleError } from '@stacksjs/error-handling'
+import { ExitCode } from '@stacksjs/types'
+
+const c = config.dns.contactInfo
+if (!c) {
+  handleError('You must provide contact info in your config file.')
+  process.exit(ExitCode.FatalError)
+}
+
+const defaultOptions: PurchaseOptions = {
+  domain: '',
+  years: 1,
+  privacy: true,
+  autoRenew: true,
+  registrantFirstName: c.firstName as string,
+  registrantLastName: c.lastName as string,
+  registrantOrganization: c.organizationName as string,
+  registrantAddressLine1: c.addressLine1 as string,
+  registrantAddressLine2: c.addressLine2 as string,
+  registrantCity: c.city as string,
+  registrantState: c.state as string,
+  registrantCountry: c.countryCode as string,
+  registrantZip: c.zip as string,
+  registrantPhone: c.phoneNumber as string,
+  registrantEmail: c.email as string,
+  adminFirstName: c.admin?.firstName || c.firstName as string,
+  adminLastName: c.admin?.lastName || c.lastName as string,
+  adminOrganization: c.admin?.organizationName || c.organizationName as string,
+  adminAddressLine1: c.admin?.addressLine1 || c.addressLine1 as string,
+  adminAddressLine2: c.admin?.addressLine2 || c.addressLine2 as string,
+  adminCity: c.admin?.city || c.city as string,
+  adminState: c.admin?.state || c.state as string,
+  adminCountry: c.admin?.countryCode || c.countryCode as string,
+  adminZip: c.admin?.zip || c.zip as string,
+  adminPhone: c.admin?.phoneNumber as string || c.phoneNumber as string,
+  adminEmail: c.admin?.email || c.email as string,
+  techFirstName: c.tech?.firstName || c.firstName as string,
+  techLastName: c.tech?.lastName || c.lastName as string,
+  techOrganization: c.tech?.organizationName || c.organizationName as string,
+  techAddressLine1: c.tech?.addressLine1 || c.addressLine1 as string,
+  techAddressLine2: c.tech?.addressLine2 || c.addressLine2 as string,
+  techCity: c.tech?.city || c.city as string,
+  techState: c.tech?.state || c.state as string,
+  techCountry: c.tech?.countryCode || c.countryCode as string,
+  techZip: c.tech?.zip || c.zip as string,
+  techPhone: c.tech?.phoneNumber as string || c.phoneNumber as string,
+  techEmail: c.tech?.email || c.email as string,
+  privacyAdmin: c.privacyAdmin || c.privacy || true,
+  privacyTech: c.privacyTech || c.privacy || true,
+  privacyRegistrant: c.privacyRegistrant || c.privacy || true,
+  contactType: 'person',
+  verbose: false,
+}
+
+const options: PurchaseOptions = { ...defaultOptions, ...parseOptions() }
+
+if (!options.domain) {
+  handleError('You must provide a domain name to purchase.')
+  process.exit(ExitCode.FatalError)
+}
+
+const result = purchaseDomain(options.domain, options)
+
+if (result.isErr()) {
+  handleError(result.error)
+  process.exit(ExitCode.FatalError)
+}
+
+log.info('Domain purchased successfully.')
+
+process.exit(ExitCode.Success)

package/src/domains/remove.ts

@@ -0,0 +1,38 @@
+import process from 'node:process'
+import { handleError } from '@stacksjs/error-handling'
+import { logger } from '@stacksjs/logging'
+import { deleteHostedZoneRecords } from '@stacksjs/dns'
+import { app } from '@stacksjs/config'
+import { parseOptions } from '@stacksjs/cli'
+
+interface RemoveOptions {
+  domain?: string
+  verbose: boolean
+}
+
+const parsedOptions = parseOptions()
+const options: RemoveOptions = {
+  domain: parsedOptions.domain as string,
+  verbose: parsedOptions.verbose as boolean,
+}
+
+if (!options.domain) {
+  if (app.url) {
+    options.domain = app.url
+  }
+  else {
+    handleError('there was no domain provided when')
+    process.exit(1)
+  }
+}
+
+if (options.verbose)
+  logger.log(`Removing domain: ${options.domain}`)
+
+// const result = await deleteHostedZone(options.domain)
+const result = await deleteHostedZoneRecords(options.domain)
+
+if (result.isErr()) {
+  handleError(result.error)
+  process.exit(1)
+}

package/src/examples.ts

@@ -0,0 +1,46 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { hasComponents } from '@stacksjs/storage'
+import { runNpmScript } from '@stacksjs/utils'
+import type { ExamplesOptions } from '@stacksjs/types'
+import { ExitCode } from '@stacksjs/types'
+import { NpmScript } from '@stacksjs/enums'
+
+export async function invoke(options: ExamplesOptions) {
+  if (options.components || options.vue)
+    await componentExample(options)
+
+  else if (options.webComponents || options.elements)
+    await webComponentExample(options)
+
+  else
+    log.error('An unsupported option was used. Please try again, check the documentation & report the issue, if needed.')
+}
+
+export async function examples(options: ExamplesOptions) {
+  return invoke(options)
+}
+
+export async function componentExample(options: ExamplesOptions) {
+  if (hasComponents()) {
+    await runNpmScript(NpmScript.ExampleVue, options)
+    log.success('Your component library was built successfully')
+  }
+  else {
+    log.info('No components found.')
+    // todo: throw custom error here
+  }
+}
+
+export async function webComponentExample(options: ExamplesOptions) {
+  if (hasComponents()) {
+    log.info('Building your Web Component library...')
+    await runNpmScript(NpmScript.BuildWebComponents, options)
+    log.success('Your Web Component library was built successfully')
+  }
+  else {
+    log.info('No components found.')
+    // todo: throw custom error here
+    process.exit(ExitCode.FatalError)
+  }
+}

package/src/fresh.ts

@@ -0,0 +1,20 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import { runCommand } from '@stacksjs/cli'
+import { logger } from '@stacksjs/logging'
+import { projectPath } from '@stacksjs/path'
+import { cleanProject } from '@stacksjs/utils'
+
+logger.log('Cleaning project...')
+await cleanProject()
+
+logger.log('Installing dependencies...')
+
+const result = await runCommand('bun install', {
+  cwd: projectPath(),
+})
+
+if (result.isErr()) {
+  handleError(result.error)
+  process.exit(ExitCode.FatalError)
+}