acrylblends 0.7.3 → 0.7.5

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

@@ -0,0 +1,50 @@
+// __STATIC_CONTENT is KVNamespace
+declare const __STATIC_CONTENT: unknown
+declare const __STATIC_CONTENT_MANIFEST: string
+
+export type KVAssetOptions = {
+  manifest?: object | string
+  // namespace is KVNamespace
+  namespace?: unknown
+}
+
+export const getContentFromKVAsset = async (
+  path: string,
+  options?: KVAssetOptions
+): Promise<ReadableStream | null> => {
+  let ASSET_MANIFEST: Record<string, string>
+
+  if (options && options.manifest) {
+    if (typeof options.manifest === 'string') {
+      ASSET_MANIFEST = JSON.parse(options.manifest)
+    } else {
+      ASSET_MANIFEST = options.manifest as Record<string, string>
+    }
+  } else {
+    if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
+      ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST)
+    } else {
+      ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST
+    }
+  }
+
+  // ASSET_NAMESPACE is KVNamespace
+  let ASSET_NAMESPACE: unknown
+  if (options && options.namespace) {
+    ASSET_NAMESPACE = options.namespace
+  } else {
+    ASSET_NAMESPACE = __STATIC_CONTENT
+  }
+
+  const key = ASSET_MANIFEST[path]
+  if (!key) {
+    return null
+  }
+
+  // @ts-expect-error ASSET_NAMESPACE is not typed
+  const content = await ASSET_NAMESPACE.get(key, { type: 'stream' })
+  if (!content) {
+    return null
+  }
+  return content as unknown as ReadableStream
+}

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

@@ -0,0 +1,52 @@
+import { WSContext, defineWebSocketHelper } from '../../helper/websocket/index.ts'
+import type { UpgradeWebSocket, WSEvents, WSReadyState } from '../../helper/websocket/index.ts'
+
+export const upgradeWebSocket: UpgradeWebSocket<
+  WebSocket,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  any,
+  Omit<WSEvents<WebSocket>, 'onOpen'>
+> = defineWebSocketHelper(async (c, events) => {
+  const upgradeHeader = c.req.header('Upgrade')
+  if (upgradeHeader !== 'websocket') {
+    return
+  }
+
+  // @ts-expect-error WebSocketPair is not typed
+  const webSocketPair = new WebSocketPair()
+  const client: WebSocket = webSocketPair[0]
+  const server: WebSocket = webSocketPair[1]
+
+  const wsContext = new WSContext<WebSocket>({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState as WSReadyState
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source),
+  })
+
+  // note: cloudflare workers doesn't support 'open' event
+
+  if (events.onClose) {
+    server.addEventListener('close', (evt: CloseEvent) => events.onClose?.(evt, wsContext))
+  }
+  if (events.onMessage) {
+    server.addEventListener('message', (evt: MessageEvent) => events.onMessage?.(evt, wsContext))
+  }
+  if (events.onError) {
+    server.addEventListener('error', (evt: Event) => events.onError?.(evt, wsContext))
+  }
+
+  // @ts-expect-error - server.accept is not typed
+  server.accept?.()
+  return new Response(null, {
+    status: 101,
+    // @ts-expect-error - webSocket is not typed
+    webSocket: client,
+  })
+})

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

@@ -0,0 +1,15 @@
+import type { Context } from '../../context.ts'
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+import type { CloudFrontEdgeEvent } from './handler.ts'
+
+type Env = {
+  Bindings: {
+    event: CloudFrontEdgeEvent
+  }
+}
+
+export const getConnInfo: GetConnInfo = (c: Context<Env>) => ({
+  remote: {
+    address: c.env.event.Records[0].cf.request.clientIp,
+  },
+})

package/plugins/acryl-router/src/core/adapter/lambda-edge/handler.ts

@@ -0,0 +1,239 @@
+import crypto from 'node:crypto'
+import type { Acryl } from '../../app.ts'
+import { decodeBase64, encodeBase64 } from '../../utils/encode.ts'
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+globalThis.crypto ??= crypto
+
+interface CloudFrontHeader {
+  key: string
+  value: string
+}
+
+interface CloudFrontHeaders {
+  [name: string]: CloudFrontHeader[]
+}
+
+interface CloudFrontCustomOrigin {
+  customHeaders: CloudFrontHeaders
+  domainName: string
+  keepaliveTimeout: number
+  path: string
+  port: number
+  protocol: string
+  readTimeout: number
+  sslProtocols: string[]
+}
+// https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
+interface CloudFrontS3Origin {
+  authMethod: 'origin-access-identity' | 'none'
+  customHeaders: CloudFrontHeaders
+  domainName: string
+  path: string
+  region: string
+}
+type CloudFrontOrigin =
+  | { s3: CloudFrontS3Origin; custom?: never }
+  | { custom: CloudFrontCustomOrigin; s3?: never }
+
+export interface CloudFrontRequest {
+  clientIp: string
+  headers: CloudFrontHeaders
+  method: string
+  querystring: string
+  uri: string
+  body?: {
+    inputTruncated: boolean
+    action: string
+    encoding: string
+    data: string
+  }
+  origin?: CloudFrontOrigin
+}
+
+export interface CloudFrontResponse {
+  headers: CloudFrontHeaders
+  status: string
+  statusDescription?: string
+}
+
+export interface CloudFrontConfig {
+  distributionDomainName: string
+  distributionId: string
+  eventType: string
+  requestId: string
+}
+
+interface CloudFrontEvent {
+  cf: {
+    config: CloudFrontConfig
+    request: CloudFrontRequest
+    response?: CloudFrontResponse
+  }
+}
+
+export interface CloudFrontEdgeEvent {
+  Records: CloudFrontEvent[]
+}
+
+type CloudFrontContext = {}
+
+export interface Callback {
+  (err: Error | null, result?: CloudFrontRequest | CloudFrontResult): void
+}
+
+// https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-generating-http-responses-in-requests.html#lambda-generating-http-responses-programming-model
+interface CloudFrontResult {
+  status: string
+  statusDescription?: string
+  headers?: {
+    [header: string]: {
+      key: string
+      value: string
+    }[]
+  }
+  body?: string
+  bodyEncoding?: 'text' | 'base64'
+}
+
+/**
+ * Accepts events from 'Lambda@Edge' event
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
+ */
+const convertHeaders = (headers: Headers): CloudFrontHeaders => {
+  const cfHeaders: CloudFrontHeaders = {}
+  headers.forEach((value, key) => {
+    cfHeaders[key.toLowerCase()] = [
+      ...(cfHeaders[key.toLowerCase()] || []),
+      { key: key.toLowerCase(), value },
+    ]
+  })
+  return cfHeaders
+}
+
+export const handle = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  app: Acryl<any>
+): ((
+  event: CloudFrontEdgeEvent,
+  context?: CloudFrontContext,
+  callback?: Callback
+) => Promise<CloudFrontResult | CloudFrontRequest>) => {
+  return async (event, ...args: [context?: CloudFrontContext, callback?: Callback]) => {
+    const [context, callback] = args
+    let callbackError: Error | null = null
+    let callbackResult: CloudFrontResult | CloudFrontRequest | undefined
+    const cf = getCloudFrontRecord(event)
+    const res = await app.fetch(createRequest(cf), {
+      event,
+      context,
+      callback: (err: Error | null, result?: CloudFrontResult | CloudFrontRequest) => {
+        if (!callbackError && !callbackResult) {
+          callbackError = err
+          callbackResult = result
+        }
+        callback?.(err, result)
+      },
+      config: cf.config,
+      request: cf.request,
+      response: cf.response,
+    })
+    if (callbackError) {
+      throw callbackError
+    }
+    return callbackResult ?? createResult(res)
+  }
+}
+
+const createResult = async (res: Response): Promise<CloudFrontResult> => {
+  const contentEncoding = res.headers.get('content-encoding')
+  const isBase64Encoded =
+    isContentTypeBinary(res.headers.get('content-type') || '') ||
+    (!!contentEncoding && !/^identity$/i.test(contentEncoding))
+  const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text()
+
+  return {
+    status: res.status.toString(),
+    headers: convertHeaders(res.headers),
+    body,
+    ...(isBase64Encoded && { bodyEncoding: 'base64' }),
+  }
+}
+
+/**
+ * Reads the CloudFront record out of a Lambda@Edge event.
+ *
+ * The event is supplied by the runtime, so a malformed one means the function
+ * was invoked with something other than a Lambda@Edge event. Fail with a
+ * message naming the adapter and the missing field, rather than letting an
+ * unattributable property access error escape.
+ */
+const getCloudFrontRecord = (event: CloudFrontEdgeEvent): CloudFrontEvent['cf'] => {
+  const cf = event?.Records?.[0]?.cf
+  if (!cf?.request) {
+    throw new TypeError(
+      'Unable to map the CloudFront event to a Request: expected `Records[0].cf.request` in the Lambda@Edge event.'
+    )
+  }
+  return cf
+}
+
+const createRequest = (cf: CloudFrontEvent['cf']): Request => {
+  const request = cf.request
+  const queryString = request.querystring
+  const host = request.headers?.host?.[0]?.value || cf.config?.distributionDomainName
+  const urlPath = `https://${host}${request.uri}`
+  const url = queryString ? `${urlPath}?${queryString}` : urlPath
+
+  const headers = new Headers()
+  Object.entries(request.headers ?? {}).forEach(([k, v]) => {
+    v.forEach((header) => headers.append(k, header.value))
+  })
+
+  const requestBody = request.body
+  const method = request.method
+  const rawBody = createBody(method, requestBody)
+
+  let body: string | Uint8Array<ArrayBuffer> | undefined = rawBody
+  if (rawBody !== undefined) {
+    const bytes =
+      typeof rawBody === 'string'
+        ? (new TextEncoder().encode(rawBody) as Uint8Array<ArrayBuffer>)
+        : rawBody
+    body = bytes
+    headers.set('content-length', bytes.length.toString())
+  }
+
+  return new Request(url, {
+    headers,
+    method,
+    body,
+  })
+}
+
+export const createBody = (
+  method: string,
+  requestBody: CloudFrontRequest['body']
+): string | Uint8Array<ArrayBuffer> | undefined => {
+  if (!requestBody || !requestBody.data) {
+    return undefined
+  }
+  if (method === 'GET' || method === 'HEAD') {
+    return undefined
+  }
+  if (requestBody.encoding === 'base64') {
+    return decodeBase64(requestBody.data)
+  }
+  return requestBody.data
+}
+
+export const isContentTypeBinary = (contentType: string): boolean => {
+  if (/^application\/vnd\.(?:apple\.installer|mozilla\.xul)\+xml\s*(?:;|$)/i.test(contentType)) {
+    return true
+  }
+
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/i.test(
+    contentType
+  )
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @module
+ * Lambda@Edge Adapter for Acryl.
+ */
+
+export { handle } from './handler.ts'
+export { getConnInfo } from './conninfo.ts'
+export type {
+  Callback,
+  CloudFrontConfig,
+  CloudFrontRequest,
+  CloudFrontResponse,
+  CloudFrontEdgeEvent,
+} from './handler.ts'

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

@@ -0,0 +1,57 @@
+import type { Context } from '../../context.ts'
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+
+/**
+ * Netlify context type
+ * @see https://docs.netlify.com/functions/api/
+ */
+type NetlifyContext = {
+  ip?: string
+  geo?: {
+    city?: string
+    country?: {
+      code?: string
+      name?: string
+    }
+    subdivision?: {
+      code?: string
+      name?: string
+    }
+    latitude?: number
+    longitude?: number
+    timezone?: string
+    postalCode?: string
+  }
+  requestId?: string
+}
+
+type Env = {
+  Bindings: {
+    context: NetlifyContext
+  }
+}
+
+/**
+ * Get connection information from Netlify
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/netlify'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export default handle(app)
+ * ```
+ */
+export const getConnInfo: GetConnInfo = (c: Context<Env>) => ({
+  remote: {
+    address: c.env.context?.ip,
+  },
+})

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

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Acryl } from '../../app.ts'
+
+export const handle = (
+  app: Acryl<any, any>
+): ((req: Request, context: any) => Response | Promise<Response>) => {
+  return (req: Request, context: any) => {
+    return app.fetch(req, { context })
+  }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * Netlify Adapter for Acryl.
+ */
+
+export * from './mod.ts'

package/plugins/acryl-router/src/core/adapter/netlify/mod.ts

@@ -0,0 +1,2 @@
+export { handle } from './handler.ts'
+export { getConnInfo } from './conninfo.ts'

package/plugins/acryl-router/src/core/adapter/service-worker/handler.ts

@@ -0,0 +1,37 @@
+/**
+ * Handler for Service Worker
+ * @module
+ */
+
+import type { Acryl } from '../../app.ts'
+import type { Env, Schema } from '../../types.ts'
+import type { FetchEvent } from './types.ts'
+
+type Handler = (evt: FetchEvent) => void
+export type HandleOptions = {
+  fetch?: typeof fetch
+}
+
+/**
+ * Adapter for Service Worker
+ */
+export const handle = <E extends Env, S extends Schema, BasePath extends string>(
+  app: Acryl<E, S, BasePath>,
+  opts: HandleOptions = {
+    // To use `fetch` on a Service Worker correctly, bind it to `globalThis`.
+    fetch: globalThis.fetch.bind(globalThis),
+  }
+): Handler => {
+  return (evt) => {
+    evt.respondWith(
+      (async () => {
+        // @ts-expect-error Passing FetchEvent but app.fetch expects ExecutionContext
+        const res = await app.fetch(evt.request, {}, evt)
+        if (opts.fetch && res.status === 404) {
+          return await opts.fetch(evt.request)
+        }
+        return res
+      })()
+    )
+  }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Service Worker Adapter for Acryl.
+ * @module
+ */
+import type { Acryl } from '../../app.ts'
+import type { Env, Schema } from '../../types.ts'
+import { handle } from './handler.ts'
+import type { HandleOptions } from './handler.ts'
+
+/**
+ * Registers a Acryl app to handle fetch events in a service worker.
+ * This sets up `addEventListener('fetch', handle(app, options))` for the provided app.
+ *
+ * @param app - The Acryl application instance
+ * @param options - Options for handling requests (fetch defaults to undefined)
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { fire } from 'acrylblends/service-worker'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => c.text('Hi'))
+ *
+ * fire(app)
+ * ```
+ */
+const fire = <E extends Env, S extends Schema, BasePath extends string>(
+  app: Acryl<E, S, BasePath>,
+  options?: HandleOptions
+): void => {
+  // @ts-expect-error addEventListener is not typed well in ServiceWorker-like contexts, see: https://github.com/microsoft/TypeScript/issues/14877
+  addEventListener('fetch', handle(app, options))
+}
+
+export { handle, fire }

package/plugins/acryl-router/src/core/adapter/service-worker/types.ts

@@ -0,0 +1,14 @@
+interface ExtendableEvent extends Event {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  waitUntil(f: Promise<any>): void
+}
+
+export interface FetchEvent extends ExtendableEvent {
+  readonly clientId: string
+  readonly handled: Promise<void>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  readonly preloadResponse: Promise<any>
+  readonly request: Request
+  readonly resultingClientId: string
+  respondWith(r: Response | PromiseLike<Response>): void
+}

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

@@ -0,0 +1,8 @@
+import type { GetConnInfo } from '../../helper/conninfo/index.ts'
+
+export const getConnInfo: GetConnInfo = (c) => ({
+  remote: {
+    // https://github.com/vercel/vercel/blob/b70bfb5fbf28a4650d4042ce68ca5c636d37cf44/packages/edge/src/edge-headers.ts#L10-L12C32
+    address: c.req.header('x-real-ip'),
+  },
+})

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

@@ -0,0 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Acryl } from '../../app.ts'
+
+export const handle =
+  (app: Acryl<any, any, any>) =>
+  (req: Request): Response | Promise<Response> => {
+    return app.fetch(req)
+  }

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

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Vercel Adapter for Acryl.
+ */
+
+export { handle } from './handler.ts'
+export { getConnInfo } from './conninfo.ts'

package/plugins/acryl-router/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-router",
-    "commit": "e79bf3de59c700667ae617f5d367cc1fd2f8e037"
+    "commit": "4721bb00960fa4e157e6070c330cf87c148739fc"
   },
   "vendored": [
     "src",
@@ -10,7 +10,7 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 6,
-  "digest": "sha256:1dd20cb7b5bb87e4368ce507dfe85de3e992cc90069a3b43e24af053b1186842",
+  "digest": "sha256:07772b7e7a2cfe416e4566bebdec7e85fb4abc30466bf104e80342b9fc4ab007",
   "testsNotRun": {
     "tests/loader.spec.ts": "loads the built lib/ entry through the real Loader; the library ships source and has no build"
   },

package/plugins/acryl-router-http/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-router-http",
-    "commit": "e79bf3de59c700667ae617f5d367cc1fd2f8e037"
+    "commit": "4721bb00960fa4e157e6070c330cf87c148739fc"
   },
   "vendored": [
     "src",

package/plugins/acryl-state/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-state",
-    "commit": "e79bf3de59c700667ae617f5d367cc1fd2f8e037"
+    "commit": "4721bb00960fa4e157e6070c330cf87c148739fc"
   },
   "vendored": [
     "src",

package/plugins/desktop/upstream.json

@@ -5,7 +5,7 @@
       "apps/acryl-desktop/src/shell/desktop-user-data.ts": "user-data.ts",
       "apps/acryl-desktop/src/shell/shutdown.ts": "shutdown.ts"
     },
-    "commit": "e79bf3de59c700667ae617f5d367cc1fd2f8e037"
+    "commit": "4721bb00960fa4e157e6070c330cf87c148739fc"
   },
   "rewrittenSpecifiers": 0,
   "digest": "sha256:7dfe960a8bbb476c35540d2202a7aaa62b33492c2ac3e34314e2ecfca45f32f2"

package/plugins/desktop-web/main.ts

@@ -1,5 +1,5 @@
 /**
- * The desktop shell of a plain Acryl app: `npm run desktop` serves the app (`src/app.ts`, `export default app`) on a free loopback port from this Electron main process and
+ * The desktop shell of a plain Acryl app: `npm run desktop` serves the app (`src/app.ts`: `export default app`, and optionally `export const close` for a database to close) on a free loopback port from this Electron main process and
  * opens one window on it. Nothing in the app imports electron; every Electron call is in this file and `window.ts`, so a different shell is a change here only.
  *
  * Order matters: the user-data folder is set before anything else (and before the single-instance lock), so one app never shares window state, logs or the lock with
@@ -36,13 +36,19 @@ if (!app.requestSingleInstanceLock()) {
 } else {
   let server: ReturnType<typeof serve> | undefined
   let window: BrowserWindow | undefined
+  /** The app module's optional `close`, for an app that owns a database: called once the server has stopped. */
+  let closeApp: (() => Promise<void>) | undefined
 
   const shutdown = createDesktopShutdown(
     () =>
       new Promise<void>((done) => {
         if (server === undefined) return done()
         server.close(() => {
-          done()
+          const closing = closeApp?.() ?? Promise.resolve()
+          closing.then(
+            () => done(),
+            () => done(),
+          )
         })
         // Open streams and keep-alive connections would hold close() open: end them.
         ;(server as { closeAllConnections?: () => void }).closeAllConnections?.()
@@ -67,7 +73,11 @@ if (!app.requestSingleInstanceLock()) {
 
   void app.whenReady().then(async () => {
     // The hook above is registered before the app's modules are loaded, so the app may have .tsx pages: they are loaded here, not as a static import.
-    const { default: acrylApp } = await import('../../app.ts')
+    const { default: acrylApp, close } = (await import('../../app.ts')) as {
+      default: { fetch: Parameters<typeof serve>[0]['fetch'] }
+      close?: () => Promise<void>
+    }
+    closeApp = close
     const port = await new Promise<number>((resolve) => {
       server = serve(
         { fetch: acrylApp.fetch, port: 0, hostname: '127.0.0.1' },

package/plugins/desktop-web/upstream.json

@@ -5,7 +5,7 @@
       "apps/acryl-desktop/src/shell/desktop-user-data.ts": "user-data.ts",
       "apps/acryl-desktop/src/shell/shutdown.ts": "shutdown.ts"
     },
-    "commit": "e79bf3de59c700667ae617f5d367cc1fd2f8e037"
+    "commit": "4721bb00960fa4e157e6070c330cf87c148739fc"
   },
   "rewrittenSpecifiers": 0,
   "digest": "sha256:7dfe960a8bbb476c35540d2202a7aaa62b33492c2ac3e34314e2ecfca45f32f2"

package/plugins/tsconfig.json

@@ -23,6 +23,7 @@
     "acryl-*/src/**/*.case.ts",
     "acryl-node-server/tests/adapter",
     "acryl-router/tests/loader.spec.ts",
+    "acryl-db-sqlite/tests/loader.spec.ts",
     "acryl-state/src/react.ts",
     "acryl-state/tests/react.spec.ts",
     "acryl-router-http/tests/adapter.spec.ts",