acrylblends 0.7.3 → 0.7.5

package/plugins/acryl-router/src/core/adapter/aws-lambda/types.ts

@@ -0,0 +1,173 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export interface CognitoIdentity {
+  cognitoIdentityId: string
+  cognitoIdentityPoolId: string
+}
+
+export interface ClientContext {
+  client: ClientContextClient
+
+  Custom?: any
+  env: ClientContextEnv
+}
+
+export interface ClientContextClient {
+  installationId: string
+  appTitle: string
+  appVersionName: string
+  appVersionCode: string
+  appPackageName: string
+}
+
+export interface ClientContextEnv {
+  platformVersion: string
+  platform: string
+  make: string
+  model: string
+  locale: string
+}
+
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+export interface LambdaContext {
+  callbackWaitsForEmptyEventLoop: boolean
+  functionName: string
+  functionVersion: string
+  invokedFunctionArn: string
+  memoryLimitInMB: string
+  awsRequestId: string
+  logGroupName: string
+  logStreamName: string
+  identity?: CognitoIdentity | undefined
+  clientContext?: ClientContext | undefined
+
+  getRemainingTimeInMillis(): number
+}
+
+type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void
+
+export type Handler<TEvent = any, TResult = any> = (
+  event: TEvent,
+  context: LambdaContext,
+  callback: Callback<TResult>
+) => void | Promise<TResult>
+
+interface ClientCert {
+  clientCertPem: string
+  subjectDN: string
+  issuerDN: string
+  serialNumber: string
+  validity: {
+    notBefore: string
+    notAfter: string
+  }
+}
+
+interface Identity {
+  accessKey?: string
+  accountId?: string
+  caller?: string
+  cognitoAuthenticationProvider?: string
+  cognitoAuthenticationType?: string
+  cognitoIdentityId?: string
+  cognitoIdentityPoolId?: string
+  principalOrgId?: string
+  sourceIp: string
+  user?: string
+  userAgent: string
+  userArn?: string
+  clientCert?: ClientCert
+}
+
+export interface ApiGatewayRequestContext {
+  accountId: string
+  apiId: string
+  authorizer: {
+    claims?: unknown
+    scopes?: unknown
+  }
+  domainName: string
+  domainPrefix: string
+  extendedRequestId: string
+  httpMethod: string
+  identity: Identity
+  path: string
+  protocol: string
+  requestId: string
+  requestTime: string
+  requestTimeEpoch: number
+  resourceId?: string
+  resourcePath: string
+  stage: string
+}
+
+interface Authorizer {
+  iam?: {
+    accessKey: string
+    accountId: string
+    callerId: string
+    cognitoIdentity: null
+    principalOrgId: null
+    userArn: string
+    userId: string
+  }
+  jwt?: {
+    claims: Record<string, string | number | boolean | string[]>
+    scopes: string[] | null
+  }
+  /**
+   * The `context` object returned by a Lambda (REQUEST) authorizer.
+   * It is `null` when the authorizer returns no context.
+   */
+  lambda?: Record<string, unknown> | null
+}
+
+export interface ApiGatewayRequestContextV2 {
+  accountId: string
+  apiId: string
+  authentication: null
+  authorizer: Authorizer
+  domainName: string
+  domainPrefix: string
+  http: {
+    method: string
+    path: string
+    protocol: string
+    sourceIp: string
+    userAgent: string
+  }
+  requestId: string
+  routeKey: string
+  stage: string
+  time: string
+  timeEpoch: number
+}
+
+export interface ALBRequestContext {
+  elb: {
+    targetGroupArn: string
+  }
+}
+
+export interface LatticeRequestContextV2 {
+  serviceNetworkArn: string
+  serviceArn: string
+  targetGroupArn: string
+  region: string
+  timeEpoch: string
+  identity: {
+    sourceVpcArn?: string
+    type?: string
+    principal?: string
+    principalOrgID?: string
+    sessionName?: string
+    x509IssuerOu?: string
+    x509SanDns?: string
+    x509SanNameCn?: string
+    x509SanUri?: string
+    x509SubjectCn?: string
+  }
+}

package/plugins/acryl-router/src/core/adapter/bun/conninfo.ts

@@ -0,0 +1,43 @@
+import type { Context } from '../../index.ts'
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+import { getBunServer } from './server.ts'
+
+/**
+ * Get ConnInfo with Bun
+ * @param c Context
+ * @returns ConnInfo
+ */
+export const getConnInfo: GetConnInfo = (c: Context) => {
+  const server = getBunServer<{
+    requestIP?: (req: Request) => {
+      address: string
+      family: string
+      port: number
+    } | null
+  }>(c)
+
+  if (!server) {
+    throw new TypeError('env has to include the 2nd argument of fetch.')
+  }
+  if (typeof server.requestIP !== 'function') {
+    throw new TypeError('server.requestIP is not a function.')
+  }
+
+  // https://bun.sh/docs/runtime/http/server#server-requestip-request
+  // Returns null for closed requests or Unix domain sockets.
+  const info = server.requestIP(c.req.raw)
+
+  if (!info) {
+    return {
+      remote: {},
+    }
+  }
+
+  return {
+    remote: {
+      address: info.address,
+      addressType: info.family === 'IPv6' || info.family === 'IPv4' ? info.family : undefined,
+      port: info.port,
+    },
+  }
+}

package/plugins/acryl-router/src/core/adapter/bun/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @module
+ * Bun Adapter for Acryl.
+ */
+
+export { serveStatic } from './serve-static.ts'
+export { bunFileSystemModule, toSSG } from './ssg.ts'
+export { createBunWebSocket, upgradeWebSocket, websocket } from './websocket.ts'
+export type { BunWebSocketData, BunWebSocketHandler } from './websocket.ts'
+export { getConnInfo } from './conninfo.ts'
+export { getBunServer } from './server.ts'

package/plugins/acryl-router/src/core/adapter/bun/serve-static.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { serveStatic as baseServeStatic } from '../../middleware/serve-static/index.ts'
+import type { ServeStaticOptions } from '../../middleware/serve-static/index.ts'
+import type { Env, MiddlewareHandler } from '../../types.ts'
+
+export const serveStatic = <E extends Env = Env>(
+  options: ServeStaticOptions<E> = {}
+): MiddlewareHandler => {
+  return async function serveStatic(c, next) {
+    const getContent = async (path: string) => {
+      // @ts-ignore
+      const file = Bun.file(path)
+      return (await file.exists()) ? file : null
+    }
+    const isDir = async (path: string) => {
+      let isDir
+      try {
+        const stats = await stat(path)
+        isDir = stats.isDirectory()
+      } catch {}
+      return isDir
+    }
+    return baseServeStatic({
+      ...options,
+      getContent,
+      join,
+      isDir,
+    })(c, next)
+  }
+}

package/plugins/acryl-router/src/core/adapter/bun/server.ts

@@ -0,0 +1,14 @@
+/**
+ * Getting Bun Server Object for Bun adapters
+ * @module
+ */
+import type { Context } from '../../context.ts'
+
+/**
+ * Get Bun Server Object from Context
+ * @template T - The type of Bun Server
+ * @param c Context
+ * @returns Bun Server
+ */
+export const getBunServer = <T>(c: Context): T | undefined =>
+  ('server' in c.env ? c.env.server : c.env) as T | undefined

package/plugins/acryl-router/src/core/adapter/bun/ssg.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { toSSG as baseToSSG } from '../../helper/ssg/index.ts'
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg/index.ts'
+
+
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export const bunFileSystemModule: FileSystemModule = {
+  writeFile: async (path, data) => {
+    // @ts-ignore
+    await Bun.write(path, data)
+  },
+  mkdir: async () => {},
+}
+
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const toSSG: ToSSGAdaptorInterface = async (app, options) => {
+  return baseToSSG(app, bunFileSystemModule, options)
+}

package/plugins/acryl-router/src/core/adapter/bun/websocket.ts

@@ -0,0 +1,113 @@
+import type { UpgradeWebSocket, WSEvents, WSMessageReceive } from '../../helper/websocket/index.ts'
+import { createWSMessageEvent, defineWebSocketHelper, WSContext } from '../../helper/websocket/index.ts'
+import { getBunServer } from './server.ts'
+
+/**
+ * @internal
+ */
+export interface BunServerWebSocket<T> {
+  send(data: string | ArrayBuffer | Uint8Array, compress?: boolean): void
+  close(code?: number, reason?: string): void
+  data: T
+  readyState: 0 | 1 | 2 | 3
+}
+
+export interface BunWebSocketHandler<T> {
+  open(ws: BunServerWebSocket<T>): void
+  close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void
+  message(ws: BunServerWebSocket<T>, message: string | { buffer: ArrayBufferLike }): void
+}
+interface CreateWebSocket<T> {
+  upgradeWebSocket: UpgradeWebSocket<T>
+  websocket: BunWebSocketHandler<BunWebSocketData>
+}
+export interface BunWebSocketData {
+  events: WSEvents
+  url: URL
+  protocol: string
+}
+
+/**
+ * @internal
+ */
+export const createWSContext = (ws: BunServerWebSocket<BunWebSocketData>): WSContext => {
+  return new WSContext({
+    send: (source, options) => {
+      ws.send(source, options?.compress)
+    },
+    raw: ws,
+    readyState: ws.readyState,
+    url: ws.data.url,
+    protocol: ws.data.protocol,
+    close(code, reason) {
+      ws.close(code, reason)
+    },
+  })
+}
+
+export const upgradeWebSocket: UpgradeWebSocket<any> = defineWebSocketHelper((c, events) => {
+  const server = getBunServer<{
+    upgrade<T>(
+      req: Request,
+      options?: {
+        data: T
+      }
+    ): boolean
+  }>(c)
+
+  if (!server) {
+    throw new TypeError('env has to include the 2nd argument of fetch.')
+  }
+  const upgradeResult = server.upgrade<BunWebSocketData>(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      // The first requested subprotocol, exposed via WSContext.protocol to
+      // match the deno and cloudflare adapters.
+      protocol: c.req.header('sec-websocket-protocol')?.split(',')[0]?.trim() ?? '',
+    },
+  })
+  if (upgradeResult) {
+    return new Response(null)
+  }
+  return // failed
+})
+
+export const websocket: BunWebSocketHandler<BunWebSocketData> = {
+  open(ws) {
+    const websocketListeners = ws.data.events
+    if (websocketListeners.onOpen) {
+      websocketListeners.onOpen(new Event('open'), createWSContext(ws))
+    }
+  },
+  close(ws, code, reason) {
+    const websocketListeners = ws.data.events
+    if (websocketListeners.onClose) {
+      websocketListeners.onClose(
+        new CloseEvent('close', {
+          code,
+          reason,
+        }),
+        createWSContext(ws)
+      )
+    }
+  },
+  message(ws, message) {
+    const websocketListeners = ws.data.events
+    if (websocketListeners.onMessage) {
+      const normalizedReceiveData: WSMessageReceive =
+        typeof message === 'string' ? message : message.buffer
+
+      websocketListeners.onMessage(createWSMessageEvent(normalizedReceiveData), createWSContext(ws))
+    }
+  },
+}
+
+/**
+ * @deprecated Import `upgradeWebSocket` and `websocket` directly from `acryl-router/bun` instead.
+ * @returns A function to create a Bun WebSocket handler.
+ */
+export const createBunWebSocket = <T>(): CreateWebSocket<T> => ({
+  upgradeWebSocket,
+  websocket,
+})

package/plugins/acryl-router/src/core/adapter/cloudflare-pages/conninfo.ts

@@ -0,0 +1,26 @@
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+
+/**
+ * Get connection information from Cloudflare Pages
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/cloudflare-pages'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const onRequest = handle(app)
+ * ```
+ */
+export const getConnInfo: GetConnInfo = (c) => ({
+  remote: {
+    address: c.req.header('cf-connecting-ip'),
+  },
+})

package/plugins/acryl-router/src/core/adapter/cloudflare-pages/handler.ts

@@ -0,0 +1,122 @@
+import { Context } from '../../context.ts'
+import type { Acryl } from '../../app.ts'
+import { HTTPException } from '../../http-exception.ts'
+import type { BlankSchema, Env, Input, MiddlewareHandler, Schema } from '../../types.ts'
+
+// Ref: https://github.com/cloudflare/workerd/blob/main/types/defines/pages.d.ts
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Params<P extends string = any> = Record<P, string | string[]>
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type EventContext<Env = {}, P extends string = any, Data = Record<string, unknown>> = {
+  request: Request
+  functionPath: string
+  waitUntil: (promise: Promise<unknown>) => void
+  passThroughOnException: () => void
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  props: any
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>
+  env: Env & { ASSETS: { fetch: typeof fetch } }
+  params: Params<P>
+  data: Data
+}
+
+declare type PagesFunction<
+  Env = unknown,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Params extends string = any,
+  Data extends Record<string, unknown> = Record<string, unknown>,
+> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>
+
+export const handle =
+  <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'>(
+    app: Acryl<E, S, BasePath>
+  ): PagesFunction<E['Bindings']> =>
+  (eventContext) => {
+    return app.fetch(
+      eventContext.request,
+      { ...eventContext.env, eventContext },
+      {
+        waitUntil: eventContext.waitUntil,
+        passThroughOnException: eventContext.passThroughOnException,
+        props: {},
+      }
+    )
+  }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(
+  middleware: MiddlewareHandler<
+    E & {
+      Bindings: {
+        eventContext: EventContext
+      }
+    },
+    P,
+    I
+  >
+): PagesFunction<E['Bindings']> {
+  return async (executionCtx) => {
+    const context = new Context(executionCtx.request, {
+      env: { ...executionCtx.env, eventContext: executionCtx },
+      executionCtx,
+    })
+
+    let response: Response | void = undefined
+
+    try {
+      response = await middleware(context, async () => {
+        try {
+          context.res = await executionCtx.next()
+        } catch (error) {
+          if (error instanceof Error) {
+            context.error = error
+          } else {
+            throw error
+          }
+        }
+      })
+    } catch (error) {
+      if (error instanceof Error) {
+        context.error = error
+      } else {
+        throw error
+      }
+    }
+
+    if (response) {
+      return response
+    }
+
+    if (context.error instanceof HTTPException) {
+      return context.error.getResponse()
+    }
+
+    if (context.error) {
+      throw context.error
+    }
+
+    return context.res
+  }
+}
+
+declare abstract class FetcherLike {
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>
+}
+
+/**
+ *
+ * @description `serveStatic()` is for advanced mode:
+ * https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+ */
+export const serveStatic = (): MiddlewareHandler => {
+  return async (c) => {
+    const env = c.env as { ASSETS: FetcherLike }
+    const res = await env.ASSETS.fetch(c.req.raw)
+    if (res.status === 404) {
+      return c.notFound()
+    }
+    return res
+  }
+}

package/plugins/acryl-router/src/core/adapter/cloudflare-pages/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @module
+ * Cloudflare Pages Adapter for Acryl.
+ *
+ * @deprecated
+ * Cloudflare recommends Workers with static assets; use `acryl` on Workers instead.
+ */
+
+export { handle, handleMiddleware, serveStatic } from './handler.ts'
+export { getConnInfo } from './conninfo.ts'
+export type { EventContext } from './handler.ts'

package/plugins/acryl-router/src/core/adapter/cloudflare-workers/conninfo.ts

@@ -0,0 +1,7 @@
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+
+export const getConnInfo: GetConnInfo = (c) => ({
+  remote: {
+    address: c.req.header('cf-connecting-ip'),
+  },
+})

package/plugins/acryl-router/src/core/adapter/cloudflare-workers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Cloudflare Workers Adapter for Acryl.
+ */
+
+export { serveStatic } from './serve-static-module.ts'
+export { upgradeWebSocket } from './websocket.ts'
+export { getConnInfo } from './conninfo.ts'

package/plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static-module.ts

@@ -0,0 +1,12 @@
+// For ES module mode
+import type { Env, MiddlewareHandler } from '../../types.ts'
+import type { ServeStaticOptions } from './serve-static.ts'
+import { serveStatic } from './serve-static.ts'
+
+const module = <E extends Env = Env>(
+  options: Omit<ServeStaticOptions<E>, 'namespace'>
+): MiddlewareHandler => {
+  return serveStatic<E>(options)
+}
+
+export { module as serveStatic }

package/plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static.ts

@@ -0,0 +1,41 @@
+import { serveStatic as baseServeStatic } from '../../middleware/serve-static/index.ts'
+import type { ServeStaticOptions as BaseServeStaticOptions } from '../../middleware/serve-static/index.ts'
+import type { Env, MiddlewareHandler } from '../../types.ts'
+import { getContentFromKVAsset } from './utils.ts'
+
+export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E> & {
+  // namespace is KVNamespace
+  namespace?: unknown
+  manifest?: object | string
+}
+
+/**
+ * @deprecated
+ * `serveStatic` in the Cloudflare Workers adapter is deprecated.
+ * You can serve static files directly using Cloudflare Static Assets.
+ * @see https://developers.cloudflare.com/workers/static-assets/
+ * Cloudflare Static Assets is currently in open beta. If this doesn't work for you,
+ * please consider using Cloudflare Pages.
+ */
+export const serveStatic = <E extends Env = Env>(
+  options: ServeStaticOptions<E> = {}
+): MiddlewareHandler => {
+  return async function serveStatic(c, next) {
+    const getContent = async (path: string) => {
+      return getContentFromKVAsset(path, {
+        manifest: options.manifest,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        namespace: options.namespace
+          ? options.namespace
+          : c.env
+            ? c.env.__STATIC_CONTENT
+            : undefined,
+      })
+    }
+    return baseServeStatic({
+      ...options,
+      getContent,
+    })(c, next)
+  }
+}