create-fullstack-scaffold 0.1.0

package/template/src/server/core/runtime-cloudflare.ts

@@ -0,0 +1,207 @@
+/**
+ * @framework-baseline 61609a9a0a7f2a0c
+ *
+ * 此文件属于框架层代码。如需修改，请添加以下说明：
+ *
+ * @framework-modify
+ * @reason [必填] 修改原因
+ * @impact [必填] 影响范围
+ */
+
+import { createRealtimeCore, type RealtimeCore } from './realtime-core'
+import type { RuntimeAdapter, RuntimePlatform, WSConnection, SSEConnection } from './runtime'
+
+class CloudflareWSConnection implements WSConnection {
+  readonly id: string
+  private ws: WebSocket
+
+  constructor(ws: WebSocket) {
+    this.id = crypto.randomUUID()
+    this.ws = ws
+  }
+
+  send(data: unknown): void {
+    this.ws.send(JSON.stringify(data))
+  }
+
+  close(): void {
+    this.ws.close()
+  }
+}
+
+export class CloudflareRuntimeAdapter implements RuntimeAdapter {
+  readonly platform: RuntimePlatform = {
+    name: 'cloudflare',
+    isCloudflare: true,
+    isNode: false,
+  }
+
+  readonly core: RealtimeCore
+  private wsPaths = new Set<string>()
+  private ssePaths = new Set<string>()
+
+  constructor() {
+    this.core = createRealtimeCore()
+  }
+
+  handleWS(path: string): void {
+    this.wsPaths.add(path)
+  }
+
+  handleSSE(path: string): void {
+    this.ssePaths.add(path)
+  }
+
+  getWSConnections(): Map<string, WSConnection> {
+    return this.core.wsClients
+  }
+
+  getSSEConnections(): Map<string, SSEConnection> {
+    return this.core.sseClients
+  }
+
+  broadcast(event: string, data: unknown, exclude: string[] = []): void {
+    console.warn(
+      `[Broadcast] event: ${event}, data: ${JSON.stringify(data)}, exclude: ${exclude}, sseClients: ${this.core.sseClients.size}`
+    )
+    this.core.broadcast(data, exclude, event)
+  }
+
+  registerRPC(method: string, handler: (params: unknown, clientId: string) => unknown): void {
+    this.core.registerRPCHandler(method, handler)
+  }
+
+  registerEvent(type: string, handler: (payload: unknown, clientId: string) => void): void {
+    this.core.registerEventHandler(type, (payload, clientId, _broadcast) => {
+      handler(payload, clientId)
+    })
+  }
+
+  hasWSPath(pathname: string): boolean {
+    return this.wsPaths.has(pathname)
+  }
+
+  hasSSEPath(pathname: string): boolean {
+    return this.ssePaths.has(pathname)
+  }
+
+  async handleWebSocketRequest(_request: Request): Promise<Response> {
+    const pair = new WebSocketPair()
+    const [client, server] = Object.values(pair) as [WebSocket, WebSocket]
+
+    server.accept()
+    const connection = new CloudflareWSConnection(server)
+
+    this.core.wsClients.set(connection.id, connection)
+
+    server.addEventListener('message', (event: MessageEvent) => {
+      try {
+        const data = JSON.parse(event.data as string)
+        this.core.handleWSMessage(connection.id, data)
+      } catch {
+        // Ignore invalid JSON messages
+      }
+    })
+
+    server.addEventListener('close', () => {
+      this.core.wsClients.delete(connection.id)
+    })
+
+    connection.send({
+      type: 'connected',
+      payload: { timestamp: Date.now() },
+    })
+
+    return new Response(null, { status: 101, webSocket: client })
+  }
+
+  async handleSSERequest(): Promise<Response> {
+    const clientId = crypto.randomUUID()
+    let keepAliveTimeout: ReturnType<typeof setTimeout> | null = null
+    let isActive = true
+
+    console.warn(
+      `[SSE] New connection, clientId: ${clientId}, current sseClients: ${this.core.sseClients.size}`
+    )
+
+    const scheduleKeepAlive = (controller: ReadableStreamDefaultController) => {
+      if (!isActive) return
+
+      keepAliveTimeout = setTimeout(() => {
+        if (!isActive) return
+
+        try {
+          controller.enqueue(new TextEncoder().encode(':ping\n\n'))
+          // Schedule next ping
+          scheduleKeepAlive(controller)
+        } catch {
+          // Connection closed, clean up
+          isActive = false
+          this.core.sseClients.delete(clientId)
+        }
+      }, 30000)
+    }
+
+    const stream = new ReadableStream({
+      start: controller => {
+        this.core.sseClients.set(clientId, {
+          id: clientId,
+          send: (msg: string) => {
+            try {
+              controller.enqueue(new TextEncoder().encode(msg))
+            } catch {
+              this.core.sseClients.delete(clientId)
+            }
+          },
+        })
+
+        console.warn(`[SSE] Client added, total sseClients: ${this.core.sseClients.size}`)
+
+        // Send initial connected event
+        const connectMsg = `event: connected\ndata: ${JSON.stringify({ timestamp: Date.now() })}\n\n`
+        controller.enqueue(new TextEncoder().encode(connectMsg))
+
+        // Start keep-alive pings using recursive setTimeout
+        scheduleKeepAlive(controller)
+      },
+      cancel: () => {
+        console.warn(`[SSE] Connection cancelled, clientId: ${clientId}`)
+        isActive = false
+        if (keepAliveTimeout) {
+          clearTimeout(keepAliveTimeout)
+          keepAliveTimeout = null
+        }
+        this.core.sseClients.delete(clientId)
+      },
+    })
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no',
+      },
+    })
+  }
+
+  async handleBroadcastRequest(request: Request): Promise<Response> {
+    const body = (await request.json()) as { event?: string; data: unknown; exclude?: string[] }
+    const event = body.event || 'notification'
+    this.core.broadcast(body.data, body.exclude || [], event)
+    return Response.json({
+      success: true,
+      wsRecipients: this.core.wsClients.size,
+      sseRecipients: this.core.sseClients.size,
+    })
+  }
+}
+
+let _instance: CloudflareRuntimeAdapter | null = null
+
+export function getCloudflareRuntimeAdapter(): CloudflareRuntimeAdapter {
+  if (!_instance) {
+    _instance = new CloudflareRuntimeAdapter()
+  }
+  return _instance
+}

package/template/src/server/core/runtime-node.ts

@@ -0,0 +1,170 @@
+/**
+ * @framework-baseline 5493efed839d774d
+ *
+ * 此文件属于框架层代码。如需修改，请添加以下说明：
+ *
+ * @framework-modify
+ * @reason [必填] 修改原因
+ * @impact [必填] 影响范围
+ */
+
+import type { WebSocket } from 'ws'
+import { createRealtimeCore, type RealtimeCore } from './realtime-core'
+import type { RuntimeAdapter, RuntimePlatform, WSConnection, SSEConnection } from './runtime'
+import { generateUUID } from '../utils/uuid'
+
+// Node.js 18+ has ReadableStream in global scope
+// For older versions, we would need to import from 'stream/web'
+
+class NodeWSConnection implements WSConnection {
+  readonly id: string
+  private ws: WebSocket
+
+  constructor(ws: WebSocket) {
+    this.id = generateUUID()
+    this.ws = ws
+  }
+
+  send(data: unknown): void {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(data))
+    }
+  }
+
+  close(): void {
+    this.ws.close()
+  }
+}
+
+export class NodeRuntimeAdapter implements RuntimeAdapter {
+  readonly platform: RuntimePlatform = {
+    name: 'node',
+    isCloudflare: false,
+    isNode: true,
+  }
+
+  private core: RealtimeCore
+  private wsPaths = new Set<string>()
+  private ssePaths = new Set<string>()
+  private _connections = new Map<string, NodeWSConnection>()
+
+  constructor() {
+    this.core = createRealtimeCore()
+  }
+
+  handleWS(path: string): void {
+    this.wsPaths.add(path)
+  }
+
+  handleSSE(path: string): void {
+    this.ssePaths.add(path)
+  }
+
+  getWSConnections(): Map<string, WSConnection> {
+    return this._connections as Map<string, WSConnection>
+  }
+
+  getSSEConnections(): Map<string, SSEConnection> {
+    return this.core.sseClients
+  }
+
+  broadcast(event: string, data: unknown, exclude: string[] = []): void {
+    this.core.broadcast(data, exclude, event)
+  }
+
+  registerRPC(method: string, handler: (params: unknown, clientId: string) => unknown): void {
+    this.core.registerRPCHandler(method, handler)
+  }
+
+  registerEvent(type: string, handler: (payload: unknown, clientId: string) => void): void {
+    this.core.registerEventHandler(type, (payload, clientId, _broadcast) => {
+      handler(payload, clientId)
+    })
+  }
+
+  hasWSPath(pathname: string): boolean {
+    return this.wsPaths.has(pathname)
+  }
+
+  hasSSEPath(pathname: string): boolean {
+    return this.ssePaths.has(pathname)
+  }
+
+  handleConnection(ws: WebSocket): NodeWSConnection {
+    const connection = new NodeWSConnection(ws)
+
+    ws.on('message', data => {
+      try {
+        const parsed = JSON.parse(data.toString())
+        this.core.handleWSMessage(connection.id, parsed)
+      } catch {
+        // Ignore invalid messages
+      }
+    })
+
+    ws.on('close', () => {
+      this._connections.delete(connection.id)
+      this.core.wsClients.delete(connection.id)
+    })
+
+    this._connections.set(connection.id, connection)
+    this.core.wsClients.set(connection.id, connection)
+
+    connection.send({
+      type: 'connected',
+      payload: { timestamp: Date.now() },
+    })
+
+    return connection
+  }
+
+  get connections(): Map<string, NodeWSConnection> {
+    return this._connections
+  }
+
+  get size(): number {
+    return this._connections.size
+  }
+
+  handleSSERequest(): Response {
+    const clientId = generateUUID()
+
+    const stream = new ReadableStream({
+      start: controller => {
+        this.core.sseClients.set(clientId, {
+          id: clientId,
+          send: (msg: string) => {
+            try {
+              controller.enqueue(new TextEncoder().encode(msg))
+            } catch {
+              this.core.sseClients.delete(clientId)
+            }
+          },
+        })
+
+        const connectMsg = `event: connected\ndata: ${JSON.stringify({ timestamp: Date.now() })}\n\n`
+        controller.enqueue(new TextEncoder().encode(connectMsg))
+      },
+      cancel: () => {
+        this.core.sseClients.delete(clientId)
+      },
+    })
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+}
+
+let _instance: NodeRuntimeAdapter | null = null
+
+export function getNodeRuntimeAdapter(): NodeRuntimeAdapter {
+  if (!_instance) {
+    _instance = new NodeRuntimeAdapter()
+  }
+  return _instance
+}

package/template/src/server/core/runtime.ts

@@ -0,0 +1,129 @@
+/**
+ * @framework-baseline af295398dc31b57a
+ *
+ * @framework-modify
+ * @reason Add handleWebSocketRequest/handleSSERequest optional methods to RuntimeAdapter interface
+ * @impact Route handlers can use adapter.handleSSERequest?() instead of 'in' + cast pattern
+ */
+
+export interface RuntimePlatform {
+  name: 'node' | 'cloudflare'
+  isCloudflare: boolean
+  isNode: boolean
+}
+
+export interface WSConnection {
+  id: string
+  send(data: unknown): void
+  close(): void
+}
+
+export interface SSEConnection {
+  id: string
+  send: (data: string) => void
+}
+
+export interface RuntimeAdapter {
+  platform: RuntimePlatform
+
+  handleWS(path: string): void
+  hasWSPath(pathname: string): boolean
+  getWSConnections(): Map<string, WSConnection>
+  broadcast(event: string, data: unknown, exclude?: string[]): void
+
+  handleSSE(path: string): void
+  hasSSEPath(pathname: string): boolean
+  getSSEConnections(): Map<string, SSEConnection>
+
+  registerRPC(method: string, handler: (params: unknown, clientId: string) => unknown): void
+  registerEvent(type: string, handler: (payload: unknown, clientId: string) => void): void
+
+  onUpgrade?(req: Request, socket: unknown, head: unknown): boolean
+
+  handleWebSocketRequest?(request: Request): Response | Promise<Response>
+  handleSSERequest?(): Response | Promise<Response>
+}
+
+declare global {
+  var __runtimeAdapter: RuntimeAdapter | undefined
+}
+
+let _adapter: RuntimeAdapter | null = null
+
+type PendingRegistration =
+  | { type: 'rpc'; method: string; handler: (params: unknown, clientId: string) => unknown }
+  | { type: 'event'; eventType: string; handler: (payload: unknown, clientId: string) => void }
+
+const _pendingRegistrations: PendingRegistration[] = []
+
+export function setRuntimeAdapter(adapter: RuntimeAdapter): void {
+  if (globalThis.__runtimeAdapter) {
+    _adapter = globalThis.__runtimeAdapter
+    return
+  }
+
+  if (_adapter) {
+    return
+  }
+
+  _adapter = adapter
+  globalThis.__runtimeAdapter = adapter
+
+  for (const pending of _pendingRegistrations) {
+    if (pending.type === 'rpc') {
+      adapter.registerRPC(pending.method, pending.handler)
+    } else {
+      adapter.registerEvent(pending.eventType, pending.handler)
+    }
+  }
+  _pendingRegistrations.length = 0
+}
+
+export function getRuntimeAdapter(): RuntimeAdapter {
+  if (globalThis.__runtimeAdapter) {
+    _adapter = globalThis.__runtimeAdapter
+  }
+
+  if (!_adapter) {
+    throw new Error('Runtime adapter not initialized. Call setRuntimeAdapter() first.')
+  }
+  return _adapter
+}
+
+export const runtime = {
+  get adapter(): RuntimeAdapter {
+    return getRuntimeAdapter()
+  },
+
+  handleWS(path: string): void {
+    this.adapter.handleWS(path)
+  },
+
+  handleSSE(path: string): void {
+    this.adapter.handleSSE(path)
+  },
+
+  broadcast(event: string, data: unknown, exclude?: string[]): void {
+    this.adapter.broadcast(event, data, exclude || [])
+  },
+
+  registerRPC(method: string, handler: (params: unknown, clientId: string) => unknown): void {
+    if (_adapter) {
+      _adapter.registerRPC(method, handler)
+    } else {
+      _pendingRegistrations.push({ type: 'rpc', method, handler })
+    }
+  },
+
+  registerEvent(type: string, handler: (payload: unknown, clientId: string) => void): void {
+    if (_adapter) {
+      _adapter.registerEvent(type, handler)
+    } else {
+      _pendingRegistrations.push({ type: 'event', eventType: type, handler })
+    }
+  },
+
+  get platform(): RuntimePlatform {
+    return this.adapter.platform
+  },
+}

package/template/src/server/core/typed-runtime.ts

@@ -0,0 +1,80 @@
+/**
+ * @framework-baseline 967517f35a849acf
+ *
+ * 此文件属于框架层代码。如需修改，请添加以下说明：
+ *
+ * @framework-modify
+ * @reason [必填] 修改原因
+ * @impact [必填] 影响范围
+ */
+
+import { runtime, type RuntimeAdapter } from './runtime'
+import type {
+  RpcMethod,
+  EventName,
+  RpcInput,
+  RpcOutput,
+  EventPayload,
+} from '@shared/core/protocol-types'
+
+export interface TypedRuntime<T extends { rpc: unknown; events: unknown }> {
+  path: string
+  get adapter(): RuntimeAdapter
+
+  registerRPC<M extends RpcMethod<T>>(
+    method: M,
+    handler: (
+      params: RpcInput<T, M>,
+      clientId: string
+    ) => RpcOutput<T, M> | Promise<RpcOutput<T, M>>
+  ): void
+
+  registerEvent<E extends EventName<T>>(
+    type: E,
+    handler: (payload: EventPayload<T, E>, clientId: string) => void
+  ): void
+
+  broadcast<E extends EventName<T>>(event: E, data: EventPayload<T, E>, exclude?: string[]): void
+}
+
+export function createTypedRuntime<T extends { rpc: unknown; events: unknown }>(
+  path: string
+): TypedRuntime<T> {
+  return {
+    path,
+    get adapter(): RuntimeAdapter {
+      return runtime.adapter
+    },
+
+    registerRPC<M extends RpcMethod<T>>(
+      method: M,
+      handler: (
+        params: RpcInput<T, M>,
+        clientId: string
+      ) => RpcOutput<T, M> | Promise<RpcOutput<T, M>>
+    ): void {
+      const wrappedHandler = (params: unknown, clientId: string): unknown => {
+        return handler(params as RpcInput<T, M>, clientId)
+      }
+      runtime.registerRPC(method as string, wrappedHandler)
+    },
+
+    registerEvent<E extends EventName<T>>(
+      type: E,
+      handler: (payload: EventPayload<T, E>, clientId: string) => void
+    ): void {
+      const wrappedHandler = (payload: unknown, clientId: string): void => {
+        handler(payload as EventPayload<T, E>, clientId)
+      }
+      runtime.registerEvent(type as string, wrappedHandler)
+    },
+
+    broadcast<E extends EventName<T>>(
+      event: E,
+      data: EventPayload<T, E>,
+      exclude?: string[]
+    ): void {
+      runtime.broadcast(event as string, data, exclude)
+    },
+  }
+}