@stacksjs/cloud 0.58.48 → 0.58.50

package/src/runtime/scripts/build-layer.ts

@@ -0,0 +1,104 @@
+// HACK: https://github.com/oven-sh/bun/issues/2081
+import { createReadStream, createWriteStream } from 'node:fs'
+import process from 'node:process'
+import { Command, Flags } from '@oclif/core'
+import { path as p } from '@stacksjs/path'
+import JSZip from 'jszip'
+
+process.stdout.getWindowSize = () => [80, 80]
+process.stderr.getWindowSize = () => [80, 80]
+
+export class BuildCommand extends Command {
+  static summary = 'Build a custom Lambda layer for Stacks & Bun.'
+
+  static flags = {
+    arch: Flags.string({
+      description: 'The architecture type to support.',
+      options: ['x64', 'aarch64'],
+      default: 'aarch64',
+    }),
+    release: Flags.string({
+      description: 'The release of Bun to install.',
+      default: 'latest',
+    }),
+    url: Flags.string({
+      description: 'A custom URL to download Bun.',
+      exclusive: ['release'],
+    }),
+    output: Flags.file({
+      exists: false,
+
+      default: async () => ['bun-lambda-layer.zip'],
+    }),
+    layer: Flags.string({
+      description: 'The name of the Lambda layer.',
+      multiple: true,
+      default: ['stacks'],
+    }),
+    region: Flags.string({
+      description: 'The region to publish the layer.',
+      multiple: true,
+      default: [],
+    }),
+    public: Flags.boolean({
+      description: 'If the layer should be public.',
+      default: false,
+    }),
+  }
+
+  async run() {
+    const result = await this.parse(BuildCommand)
+    const { flags } = result
+    this.debug('Options:', flags)
+    const { arch, release, url, output } = flags
+    const { href } = new URL(url ?? `https://bun.sh/download/${release}/linux/${arch}?avx2=true`)
+    this.log('Downloading...', href)
+    const response = await fetch(href, {
+      headers: {
+        'User-Agent': 'stacks-lambda',
+      },
+    })
+    if (response.url !== href)
+      this.debug('Redirected URL:', response.url)
+
+    this.debug('Response:', response.status, response.statusText)
+    if (!response.ok) {
+      const reason = await response.text()
+      this.error(reason, { exit: 1 })
+    }
+    this.log('Extracting...')
+    const buffer = await response.arrayBuffer()
+    let archive
+    try {
+      archive = await JSZip.loadAsync(buffer)
+    }
+    catch (cause) {
+      this.debug(cause)
+      this.error('Failed to unzip file:', { exit: 1 })
+    }
+    this.debug('Extracted archive:', Object.keys(archive.files))
+    const bun = archive.filter((_, { dir, name }) => !dir && name.endsWith('bun'))[0]
+    if (!bun)
+      this.error('Failed to find executable in zip', { exit: 1 })
+
+    const cwd = bun.name.split('/')[0]
+    archive = archive.folder(cwd) ?? archive
+    for (const filename of ['bootstrap', 'runtime.ts']) {
+      const path = p.join(__dirname, '..', filename)
+      archive.file(filename, createReadStream(path))
+    }
+    this.log('Saving...', output)
+    archive
+      .generateNodeStream({
+        streamFiles: true,
+        compression: 'DEFLATE',
+        compressionOptions: {
+          level: 9,
+        },
+      })
+      .pipe(createWriteStream(p.projectStoragePath(`framework/cloud/${output}`)))
+    this.log('Saved')
+  }
+}
+
+await BuildCommand.run(process.argv.slice(2))

package/src/runtime/scripts/publish-layer.ts

@@ -0,0 +1,110 @@
+import { spawnSync } from 'node:child_process'
+import process from 'node:process'
+import { BuildCommand } from './build-layer'
+
+export class PublishCommand extends BuildCommand {
+  static summary = 'Publish a custom Lambda layer for Bun.'
+
+  #aws(args: string[]): string {
+    this.debug('$', 'aws', ...args)
+    const { status, stdout, stderr } = spawnSync('aws', args, {
+      stdio: 'pipe',
+    })
+    const result = stdout.toString('utf-8').trim()
+    if (status === 0)
+      return result
+
+    const reason = stderr.toString('utf-8').trim() || result
+    throw new Error(`aws ${args.join(' ')} exited with ${status}: ${reason}`)
+  }
+
+  async run() {
+    const { flags } = await this.parse(PublishCommand)
+    this.debug('Options:', flags)
+    try {
+      const version = this.#aws(['--version'])
+      this.debug('AWS CLI:', version)
+    }
+    catch (error) {
+      this.debug(error)
+      this.error(
+        'Install the `aws` CLI to continue: https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html',
+        { exit: 1 },
+      )
+    }
+    const { layer, region, arch, output, public: _isPublic } = flags
+    if (region.includes('*')) {
+      // prettier-ignore
+      const result = this.#aws([
+        'ec2',
+        'describe-regions',
+        '--query',
+        'Regions[].RegionName',
+        '--output',
+        'json',
+      ])
+      region.length = 0
+      for (const name of JSON.parse(result))
+        region.push(name)
+    }
+    else if (!region.length) {
+      // prettier-ignore
+      region.push(this.#aws([
+        'configure',
+        'get',
+        'region',
+      ]))
+    }
+    this.log('Publishing...')
+    for (const regionName of region) {
+      for (const layerName of layer) {
+        // prettier-ignore
+        const result = this.#aws([
+          'lambda',
+          'publish-layer-version',
+          '--layer-name',
+          layerName,
+          '--region',
+          regionName,
+          '--description',
+          'Bun is an incredibly fast JavaScript runtime, bundler, transpiler, and package manager.',
+          '--license-info',
+          'MIT',
+          '--compatible-architectures',
+          arch === 'x64' ? 'x86_64' : 'arm64',
+          '--compatible-runtimes',
+          'provided.al2',
+          'provided',
+          '--zip-file',
+`fileb://${output}`,
+'--output',
+'json',
+        ])
+        const { LayerVersionArn } = JSON.parse(result)
+        this.log('Published', LayerVersionArn)
+        // if (isPublic) {
+        // prettier-ignore
+        this.#aws([
+          'lambda',
+          'add-layer-version-permission',
+          '--layer-name',
+          layerName,
+          '--region',
+          regionName,
+          '--version-number',
+          LayerVersionArn.split(':').pop(),
+          '--statement-id',
+`${layerName}-public`,
+'--action',
+'lambda:GetLayerVersion',
+'--principal',
+'*',
+        ])
+        // }
+      }
+    }
+    this.log('Done')
+  }
+}
+
+await PublishCommand.run(process.argv.slice(2))

package/src/runtime/server.ts

@@ -0,0 +1,39 @@
+import type { Server } from 'bun'
+import { serverResponse } from '@stacksjs/router'
+
+export default {
+  async fetch(request: Request, server: Server): Promise<Response | undefined> {
+    // eslint-disable-next-line no-console
+    console.log('Request', {
+      url: request.url,
+      method: request.method,
+      headers: request.headers.toJSON(),
+      body: request.body ? await request.text() : null,
+    })
+
+    if (server.upgrade(request)) {
+      // eslint-disable-next-line no-console
+      console.log('WebSocket upgraded')
+      return
+    }
+
+    return serverResponse(request)
+  },
+
+  websocket: {
+    // async open(ws: ServerWebSocket): Promise<void> {
+    //   // eslint-disable-next-line no-console
+    //   console.log('WebSocket opened')
+    // },
+
+    // async message(ws: ServerWebSocket, message: string): Promise<void> {
+    //   // eslint-disable-next-line no-console
+    //   console.log('WebSocket message', message)
+    // },
+
+    // async close(ws: ServerWebSocket, code: number, reason?: string): Promise<void> {
+    //   // eslint-disable-next-line no-console
+    //   console.log('WebSocket closed', { code, reason })
+    // },
+  },
+}

package/src/types.ts

@@ -0,0 +1,28 @@
+import type { AppEnvType } from '@stacksjs/types'
+import type { StackProps } from 'aws-cdk-lib'
+
+export interface CloudOptions extends StackProps {
+  name: string
+  env: {
+    account: string
+    region: string
+  }
+  slug: string
+  appEnv: AppEnvType
+  appName: string
+  domain: string
+  timestamp: string
+}
+
+export interface NestedCloudProps {
+  name: string
+  env: {
+    account: string
+    region: string
+  }
+  slug: string
+  appEnv: AppEnvType
+  appName: string
+  domain: string
+  timestamp: string
+}