@stacksjs/buddy 0.58.48 → 0.58.49

package/src/commands/dev.ts

@@ -0,0 +1,268 @@
+import process from 'node:process'
+import { Action } from '@stacksjs/enums'
+import {
+  runAction,
+  runApiDevServer,
+  runComponentsDevServer,
+  runDashboardDevServer,
+  runDesktopDevServer,
+  runDocsDevServer,
+  runFrontendDevServer,
+  runSystemTrayDevServer,
+} from '@stacksjs/actions'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, DevOptions } from '@stacksjs/types'
+import { intro, log, outro, prompt, runCommand } from '@stacksjs/cli'
+import { libsPath } from '@stacksjs/path'
+
+export function dev(buddy: CLI) {
+  const descriptions = {
+    dev: 'Starts development server',
+    frontend: 'Starts the frontend development server',
+    components: 'Start the Components development server',
+    desktop: 'Start the Desktop App development server',
+    dashboard: 'Start the Dashboard development server',
+    api: 'Start the local API development server',
+    email: 'Start the Email development server',
+    docs: 'Start the Documentation development server',
+    systemTray: 'Start the System Tray development server',
+    interactive: 'Get asked which development server to start',
+    select: 'Which development server are you trying to start?',
+    withLocalhost: 'Include the localhost URL in the output',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('dev [server]', descriptions.dev) // server is optional because options can be used
+    .option('-f, --frontend', descriptions.frontend)
+    .option('-a, --api', descriptions.api)
+    .option('-e, --email', descriptions.email)
+    .option('-c, --components', descriptions.components)
+    .option('-d, --dashboard', descriptions.dashboard)
+    .option('-t, --desktop', descriptions.desktop)
+    .option('-d, --docs', descriptions.docs)
+    .option('-t, --system-tray', descriptions.systemTray)
+    .option('-i, --interactive', descriptions.interactive, { default: false })
+    .option('-l, --with-localhost', descriptions.withLocalhost, { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (server: string | undefined, options: DevOptions) => {
+      const perf = await intro('buddy dev')
+
+      // log.info('Ensuring web server/s running...') // in other words, ensure caddy is running
+
+      // // check if port 443 is open
+      // const result = await runCommand('lsof -i :443', { silent: true })
+
+      // if (result.isErr())
+      //   log.warn('While checking if port 443 is open, we noticed it may be in use')
+
+      // runAction(Action.StartCaddy, { ...options, silent: true })
+
+      switch (server) {
+        case 'frontend':
+          await runFrontendDevServer(options)
+          break
+        case 'api':
+          await runApiDevServer(options)
+          break
+        case 'components':
+          await runComponentsDevServer(options)
+          break
+        case 'dashboard':
+          await runDashboardDevServer(options)
+          break
+        case 'desktop':
+          await runDesktopDevServer(options)
+          break
+        case 'system-tray':
+          await runSystemTrayDevServer(options)
+          break
+          // case 'email':
+          //   await runEmailDevServer(options)
+          //   break
+        case 'docs':
+          await runDocsDevServer(options)
+          break
+        default:
+      }
+
+      if (wantsInteractive(options)) {
+        const answer = await prompt.require()
+          .select(descriptions.select, {
+            options: [
+              { value: 'all', label: 'All' },
+              { value: 'frontend', label: 'Frontend' },
+              { value: 'api', label: 'Backend' },
+              { value: 'dashboard', label: 'Dashboard' },
+              { value: 'desktop', label: 'Desktop' },
+              { value: 'email', label: 'Email' },
+              { value: 'components', label: 'Components' },
+              { value: 'docs', label: 'Documentation' },
+            ],
+          })
+
+        if (answer === 'components') {
+          await runComponentsDevServer(options)
+        }
+        else if (answer === 'api') {
+          await runApiDevServer(options)
+        }
+        else if (answer === 'dashboard') {
+          await runDashboardDevServer(options)
+        }
+        // else if (answer === 'email')
+        //   await runEmailDevServer(options)
+        else if (answer === 'docs') {
+          await runDocsDevServer(options)
+        }
+
+        else {
+          log.error('Invalid option during interactive mode')
+          process.exit(ExitCode.InvalidArgument)
+        }
+      }
+
+      else {
+        if (options.components)
+          await runComponentsDevServer(options)
+        if (options.docs)
+          await runDocsDevServer(options)
+        else if (options.api)
+          await runApiDevServer(options)
+        // else if (options.email)
+        //   await runEmailDevServer(options)
+      }
+
+      await startDevelopmentServer(options)
+
+      outro('Exited', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('dev:components', descriptions.components)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      const perf = await intro('buddy dev:components')
+      const result = await runCommand('bun run dev', {
+        cwd: libsPath('components/vue'),
+        // silent: !options.verbose,
+      })
+
+      if (options.verbose)
+        log.info('buddy dev:components result', result)
+
+      if (result.isErr()) {
+        await outro('While running the dev:components command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      // eslint-disable-next-line no-console
+      console.log('')
+      await outro('Exited', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('dev:docs', descriptions.docs)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      const perf = await intro('buddy dev:docs')
+      const result = await runAction(Action.DevDocs, options)
+
+      if (result.isErr()) {
+        await outro('While running the dev:docs command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      // eslint-disable-next-line no-console
+      console.log('')
+      await outro('Exited', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('dev:desktop', descriptions.desktop)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      const perf = await intro('buddy dev:desktop')
+      const result = await runAction(Action.DevDesktop, options)
+
+      if (result.isErr()) {
+        await outro('While running the dev:desktop command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      // eslint-disable-next-line no-console
+      console.log('')
+      await outro('Exited', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('dev:api', descriptions.api)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      await runApiDevServer(options)
+    })
+
+  // buddy
+  //   .command('dev:functions', descriptions.api)
+    .option('-p, --project', descriptions.project, { default: false })//
+    .option('--verbose', descriptions.verbose, { default: false })
+  //   .action(async (options: DevOptions) => {
+  //     await runFunctionsDevServer(options)
+  //   })
+
+  buddy
+    .command('dev:frontend', descriptions.frontend)
+    .alias('dev:pages')
+    .alias('dev:views')
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      await runFrontendDevServer(options)
+    })
+
+  buddy
+    .command('dev:dashboard', descriptions.dashboard)
+    .alias('dev:admin')
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      await runDashboardDevServer(options)
+    })
+
+  buddy
+    .command('dev:system-tray', descriptions.systemTray)
+    .alias('dev:tray')
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DevOptions) => {
+      await runSystemTrayDevServer(options)
+    })
+
+  buddy.on('dev:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}
+
+export async function startDevelopmentServer(options: DevOptions) {
+  const result = await runAction(Action.Dev, options)
+
+  if (result.isErr()) {
+    log.error('While running the dev command, there was an issue', result.error)
+    process.exit(ExitCode.InvalidArgument)
+  }
+}
+
+function wantsInteractive(options: DevOptions) {
+  return options.interactive
+}

package/src/commands/dns.ts

@@ -0,0 +1,80 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI } from '@stacksjs/types'
+import { config } from '@stacksjs/config'
+import { runCommand } from '@stacksjs/cli'
+
+// import { Action } from '@stacksjs/enums'
+// import { runAction } from '@stacksjs/actions'
+
+interface DnsOptions {
+  query?: string
+  type?: string
+  nameserver?: string
+  class?: string
+  udp?: boolean
+  tcp?: boolean
+  tls?: boolean
+  https?: boolean
+  short?: boolean
+  json?: boolean
+  pretty?: boolean
+  p?: boolean // short for pretty
+  verbose?: boolean
+}
+
+export function dns(buddy: CLI) {
+  const descriptions = {
+    dns: 'Lists the DNS records for a domain',
+    query: 'Host name or IP address to query',
+    type: 'Type of the DNS record being queried (A, MX, NS…)',
+    nameserver: 'Address of the nameserver to send packets to',
+    class: 'Network class of the DNS record being queried (IN, CH, HS)',
+    udp: 'Use the DNS protocol over UDP',
+    tcp: 'Use the DNS protocol over TCP',
+    tls: 'Use the DNS-over-TLS protocol',
+    https: 'Use the DNS-over-HTTPS protocol',
+    short: 'Short mode: display nothing but the first result',
+    json: 'Display the output as JSON',
+    pretty: 'Display the output as JSON in a pretty format',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('dns [domain]', descriptions.dns)
+    .option('-q, --query <query>', descriptions.query)
+    .option('-t, --type <type>', descriptions.type, { default: 'ANY' })
+    .option('-n, --nameserver <nameserver>', descriptions.nameserver)
+    .option('--class <class>', descriptions.nameserver)
+    // transport options
+    .option('-U, --udp', descriptions.udp)
+    .option('-T, --tcp', descriptions.tcp)
+    .option('-S, --tls', descriptions.tls)
+    .option('-H, --https', descriptions.https)
+    // output options
+    .option('-1, --short', descriptions.short, { default: false })
+    .option('-J, --json', descriptions.json, { default: false })
+    .option('-p, --pretty', descriptions.pretty, { default: true })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (domain: string | undefined, options: DnsOptions) => {
+      // let prettyOutput = false
+
+      // if (options.json && options.pretty)
+      //   prettyOutput = true
+
+      delete options.pretty
+      delete options.p
+
+      // Convert options object to command-line options string
+      const optionsString = Object.entries(options)
+        .filter(([key, value]) => key !== '--' && key.length > 1 && value !== false) // filter out '--' key and short options
+        .map(([key, value]) => `--${key} ${value}`)
+        .join(' ')
+
+      await runCommand(`dog ${domain || config.app.url} ${optionsString}`)
+
+      process.exit(ExitCode.Success)
+    })
+}

package/src/commands/domains.ts

@@ -0,0 +1,158 @@
+import process from 'node:process'
+import { runAction } from '@stacksjs/actions'
+import { bgCyan, bold, intro, italic, outro, prompts } from '@stacksjs/cli'
+import { config } from '@stacksjs/config'
+import { addDomain } from '@stacksjs/dns'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, DomainsOptions } from '@stacksjs/types'
+import { Action } from '@stacksjs/enums'
+
+export function domains(buddy: CLI) {
+  const descriptions = {
+    purchase: 'Purchase a domain',
+    add: 'Add a domain to your cloud', // given you already own it with a different registrar
+    remove: 'Remove a domain from your cloud',
+    skip: 'Skip the confirmation prompt',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  const c = config.dns.contactInfo
+
+  buddy
+    .command('domains:purchase <domain>', descriptions.purchase)
+    .option('--years <years>', 'Number of years to purchase the domain for', { default: 1 })
+    .option('--privacy', 'Enable privacy protection', { default: true })
+    .option('--auto-renew', 'Enable auto-renew', { default: true })
+    .option('--first-name <firstName>', 'Registrant first name', { default: c?.firstName })
+    .option('--last-name <lastName>', 'Registrant last name', { default: c?.lastName })
+    .option('--organization <organization>', 'Registrant organization name', { default: c?.organizationName })
+    .option('--address-line1 <address>', 'Registrant address line 1', { default: c?.addressLine1 })
+    .option('--address-line2 <address>', 'Registrant address line 2', { default: c?.addressLine2 })
+    .option('--city <city>', 'Registrant city', { default: c?.city })
+    .option('--state <state>', 'Registrant state', { default: c?.state })
+    .option('--country <country>', 'Registrant country code', { default: c?.countryCode })
+    .option('--zip <zip>', 'Registrant zip', { default: c?.zip })
+    .option('--phone <phone>', 'Registrant phone', { default: c?.phoneNumber })
+    .option('--email <email>', 'Registrant email', { default: c?.email })
+    .option('--admin-first-name <firstName>', 'Admin first name', { default: c?.admin?.firstName || c?.firstName })
+    .option('--admin-last-name <lastName>', 'Admin last name', { default: c?.admin?.lastName || c?.lastName })
+    .option('--admin-organization <organization>', 'Admin organization', { default: c?.admin?.organizationName || c?.organizationName })
+    .option('--admin-address-line1 <address>', 'Admin address line 1', { default: c?.admin?.addressLine1 || c?.addressLine1 })
+    .option('--admin-address-line2 <address>', 'Admin address line 2', { default: c?.admin?.addressLine2 || c?.addressLine2 })
+    .option('--admin-city <city>', 'Admin city', { default: c?.admin?.city || c?.city })
+    .option('--admin-state <state>', 'Admin state', { default: c?.admin?.state || c?.state })
+    .option('--admin-country <country>', 'Admin country code', { default: c?.admin?.countryCode || c?.countryCode })
+    .option('--admin-zip <zip>', 'Admin zip', { default: c?.admin?.zip || c?.zip })
+    .option('--admin-phone <phone>', 'Admin phone number', { default: c?.admin?.phoneNumber || c?.phoneNumber })
+    .option('--admin-email <email>', 'Admin email', { default: c?.admin?.email || c?.email })
+    .option('--tech-first-name <firstName>', 'Tech first name', { default: c?.tech?.firstName || c?.firstName })
+    .option('--tech-last-name <lastName>', 'Tech last name', { default: c?.tech?.lastName || c?.lastName })
+    .option('--tech-organization <organization>', 'Tech organization name', { default: c?.tech?.organizationName || c?.organizationName })
+    .option('--tech-address-line1 <address>', 'Tech address line 1', { default: c?.tech?.addressLine1 || c?.addressLine1 })
+    .option('--tech-address-line2 <address>', 'Tech address line 2', { default: c?.tech?.addressLine2 || c?.addressLine2 })
+    .option('--tech-city <city>', 'Tech city', { default: c?.tech?.city || c?.city })
+    .option('--tech-state <state>', 'Tech state', { default: c?.tech?.state || c?.state })
+    .option('--tech-country <country>', 'Tech country', { default: c?.tech?.countryCode || c?.countryCode })
+    .option('--tech-zip <zip>', 'Tech zip', { default: c?.tech?.zip || c?.zip })
+    .option('--tech-phone <phone>', 'Tech phone', { default: c?.tech?.phoneNumber || c?.phoneNumber })
+    .option('--tech-email <email>', 'Tech email', { default: c?.tech?.email || c?.email })
+    .option('--privacy-admin', 'Enable privacy protection for admin', { default: c?.privacyAdmin || c?.privacy || true })
+    .option('--privacy-tech', 'Enable privacy protection for tech', { default: c?.privacyTech || c?.privacy || true })
+    .option('--privacy-registrant', 'Enable privacy protection for registrant', { default: c?.privacyRegistrant || c?.privacy || true })
+    .option('--contact-type <type>', 'Contact type', { default: 'person' })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (domain: string, options: DomainsOptions) => {
+      options.domain = domain
+      const startTime = await intro('buddy domains:purchase')
+      const result = await runAction(Action.DomainsPurchase, options)
+
+      if (result.isErr()) {
+        await outro('While running the domains:purchase command, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      const { confirm } = await prompts({
+        name: 'confirm',
+        type: 'confirm',
+        message: `Would you like to set ${domain} as your APP_URL?`,
+      })
+
+      if (!confirm) {
+        await outro(`Alrighty! ${italic(domain)} was added to your account.`, { startTime, useSeconds: true, type: 'success' })
+        log.info(`Please note, you may need to validate your email address. Check your ${italic(options.registrantEmail as string)} inbox.`)
+        process.exit(ExitCode.Success)
+      }
+
+      // set .env APP_URL to domain
+      const { writeEnv } = await import('@stacksjs/env')
+      writeEnv('APP_URL', domain)
+
+      let message = `Great! ${italic(domain)} was added to your account.`
+      message += `\n\nAnd your APP_URL has been set to ${italic(domain)}.
+      \nPlease note, this change has not been deployed yet.
+      \nThe next time you run ${bgCyan(italic(bold(' buddy deploy ')))}, your app will deploy to ${italic(domain)}.
+      \n${italic('You may need to deploy 2-3 times for the changes to take effect. Issue tracked here: https://github.com/stacksjs/stacks/issues/685')}`
+
+      await outro(message, { startTime, useSeconds: true, type: 'info' })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('domains:add <domain>', descriptions.add)
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DomainsOptions) => {
+      const startTime = await intro('buddy domains:add')
+      const result = await addDomain({
+        ...options,
+        startTime,
+      })
+
+      if (result.isErr()) {
+        await outro('While running the `buddy deploy`, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Added your domain.', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('domains:remove <domain>', descriptions.remove)
+    .option('--yes', descriptions.skip, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DomainsOptions) => {
+      const domain = options.domain || config.app.url
+      const opts = { ...options, domain }
+      const startTime = await intro('buddy domains:remove')
+
+      if (!opts.yes) {
+        const { confirm } = await prompts({
+          name: 'confirm',
+          type: 'confirm',
+          message: `Are you sure you want to remove ${domain}?`,
+        })
+
+        if (!confirm) {
+          await outro('Cancelled the domains:remove command', { startTime, useSeconds: true, type: 'info' })
+          process.exit(ExitCode.Success)
+        }
+      }
+
+      const result = await runAction(Action.DomainsRemove, opts)
+
+      if (result.isErr()) {
+        await outro('While running the domains:remove command, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Removed your domain DNS records.', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('domains:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/example.ts

@@ -0,0 +1,66 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, ExamplesOptions } from '@stacksjs/types'
+import { runExample } from '@stacksjs/actions'
+
+export function example(buddy: CLI) {
+  const descriptions = {
+    example: 'Which example do you want to see?',
+    components: 'Test your libraries against your built bundle',
+    vue: 'Test your Vue component library',
+    webComponents: 'Test your web component library',
+    select: 'Which example are you trying to view?',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('example', descriptions.example)
+    .option('-c, --components', descriptions.components)
+    .option('-v, --vue', descriptions.vue)
+    .option('-w, --web-components', descriptions.webComponents)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: ExamplesOptions) => {
+      // const answer = await prompt.require()
+      //   .select(descriptions.select, {
+      //     options: [
+      //       { value: 'components', label: 'Vue Components' },
+      //       { value: 'web-components', label: 'Web Components' },
+      //     ],
+      //   })
+
+      // if (answer === 'components')
+      //   await componentExample(options)
+      // else if (answer === 'web-components')
+      //   await webComponentExample(options)
+      // else process.exit(ExitCode.InvalidArgument)
+
+      await runExample(options)
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('example:vue', descriptions.vue)
+    .option('-v, --vue', descriptions.verbose, { default: true })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .alias('example:components')
+    .action(async (options: ExamplesOptions) => {
+      await runExample(options)
+    })
+
+  buddy
+    .command('example:web-components', 'Test your Web Component library.')
+    .option('-w, --web-components', descriptions.verbose, { default: true })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: ExamplesOptions) => {
+      await runExample(options)
+    })
+
+  buddy.on('example:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/fresh.ts

@@ -0,0 +1,36 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, FreshOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, outro } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+
+export function fresh(buddy: CLI) {
+  const descriptions = {
+    fresh: 'Reinstalls your npm dependencies',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('fresh', descriptions.fresh)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: FreshOptions) => {
+      const perf = await intro('buddy fresh')
+      const result = await runAction(Action.Fresh, { ...options, stdout: 'inherit' })
+
+      if (result.isErr()) {
+        await outro('While running `buddy fresh`, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Freshly reinstalled your dependencies', { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('fresh:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}