CN.3088943772611786:29cc3c061aa7edf0f24b3e1b876ab524_692a83143c08859077f01006.692a831e3c08859077f0100a.692a831ed6fc465b4922d366:Trae CN.T(2025/11/29 13:22:38)

packages/core/package.json

@@ -283,7 +283,8 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "resolve": "^1.20.0",
-    "uuid": "^13.0.0"
+    "uuid": "^13.0.0",
+    "ws": "^8.14.2"
   },
   "devDependencies": {
     "@keystone-6/core": "workspace:^",

packages/core/src/___internal-do-not-use-will-break-in-patch/admin-ui/pages/App/SchemaRefreshListener.tsx

@@ -0,0 +1,28 @@
+import { useEffect } from 'react';
+import { useRouter } from 'next/router';
+
+export function SchemaRefreshListener() {
+  const router = useRouter();
+
+  useEffect(() => {
+    // Only connect in development mode
+    if (process.env.NODE_ENV !== 'development') return;
+
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const socket = new WebSocket(`${protocol}//${window.location.host}/__keystone/schema-refresh`);
+
+    socket.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      if (data.type === 'SCHEMA_CHANGED') {
+        // Reload the page to reflect schema changes
+        router.reload();
+      }
+    };
+
+    return () => {
+      socket.close();
+    };
+  }, [router]);
+
+  return null;
+}

packages/core/src/___internal-do-not-use-will-break-in-patch/admin-ui/pages/App/index.tsx

@@ -2,6 +2,7 @@ import type { AppProps } from 'next/app'
 import type { AdminConfig, FieldViews } from '../../../../types'
 import { ErrorBoundary } from '../../../../admin-ui/components'
 import { KeystoneProvider } from '../../../../admin-ui/context'
+import { SchemaRefreshListener } from './SchemaRefreshListener'
 
 type AppConfig = {
   adminConfig: AdminConfig
@@ -14,6 +15,7 @@ export const getApp =
   ({ Component, pageProps }: AppProps) => {
     return (
       <KeystoneProvider {...props}>
+        <SchemaRefreshListener />
         <ErrorBoundary>
           <Component {...pageProps} />
         </ErrorBoundary>

packages/core/src/lib/express.ts

@@ -10,6 +10,7 @@ import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin
 // @ts-expect-error
 import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.js'
 import type { KeystoneContext, KeystoneConfig } from '../types'
+import { createSchemaRefreshServer, SchemaRefreshServer } from './schemaRefresh'
 
 /*
 NOTE: This creates the main Keystone express server, including the
@@ -57,9 +58,12 @@ export async function createExpressServer(
   expressServer: express.Express
   apolloServer: ApolloServer<KeystoneContext>
   httpServer: Server
+  schemaRefreshServer: SchemaRefreshServer
 }> {
   const expressServer = express()
   const httpServer = createServer(expressServer)
+  const schemaRefreshServer = createSchemaRefreshServer()
+  schemaRefreshServer.start(httpServer)
 
   if (config.server.cors !== null) {
     expressServer.use(cors(config.server.cors))
@@ -105,5 +109,5 @@ export async function createExpressServer(
     })
   )
 
-  return { expressServer, apolloServer, httpServer }
+  return { expressServer, apolloServer, httpServer, schemaRefreshServer }
 }

packages/core/src/lib/schemaRefresh.ts

@@ -0,0 +1,52 @@
+import WebSocket from 'ws';
+import { Server } from 'http';
+import { KeystoneConfig } from '../types';
+import { System } from '../lib/system';
+
+export interface SchemaRefreshServer {
+  start(httpServer: Server): void;
+  stop(): void;
+  notifySchemaChange(): void;
+}
+
+export function createSchemaRefreshServer(): SchemaRefreshServer {
+  let wss: WebSocket.Server | null = null;
+
+  return {
+    start(httpServer: Server) {
+      wss = new WebSocket.Server({ noServer: true });
+
+      httpServer.on('upgrade', (request, socket, head) => {
+        if (request.url === '/__keystone/schema-refresh') {
+          wss!.handleUpgrade(request, socket, head, (ws) => {
+            wss!.emit('connection', ws, request);
+          });
+        }
+      });
+
+      wss.on('connection', (ws) => {
+        console.log('Schema refresh client connected');
+        ws.on('close', () => {
+          console.log('Schema refresh client disconnected');
+        });
+      });
+    },
+
+    stop() {
+      if (wss) {
+        wss.close();
+        wss = null;
+      }
+    },
+
+    notifySchemaChange() {
+      if (wss) {
+        wss.clients.forEach((client) => {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(JSON.stringify({ type: 'SCHEMA_CHANGED' }));
+          }
+        });
+      }
+    }
+  };
+}

packages/core/src/scripts/dev.ts

@@ -19,6 +19,7 @@ import {
 } from '../artifacts'
 import { printPrismaSchema } from '../lib/core/prisma-schema-printer'
 import { createExpressServer } from '../lib/express'
+import { SchemaRefreshServer } from '../lib/schemaRefresh'
 import { createAdminUIMiddlewareWithNextApp } from '../lib/middleware'
 import { withMigrate } from '../lib/migrations'
 import { confirmPrompt } from '../lib/prompts'
@@ -142,6 +143,7 @@ export async function dev(
   const httpServer = app ? createServer(app) : null
   let expressServer: express.Express | null = null
   let hasAddedAdminUIMiddleware = false
+  let schemaRefreshServer: SchemaRefreshServer | null = null
   const isReady = () => !server || (expressServer !== null && hasAddedAdminUIMiddleware)
 
   const initKeystone = async () => {
@@ -247,10 +249,11 @@ export async function dev(
           }
 
           log('✨ Creating server')
-          const { apolloServer, expressServer } = await createExpressServer(
+          const { apolloServer, expressServer, schemaRefreshServer: newSchemaRefreshServer } = await createExpressServer(
             system.config,
             keystone.context
           )
+          schemaRefreshServer = newSchemaRefreshServer
           log(`✅ GraphQL API ready`)
 
           return {
@@ -363,6 +366,13 @@ export async function dev(
             expressServer = servers.expressServer
             const prevApolloServer = lastApolloServer
             lastApolloServer = servers.apolloServer
+            // Update schema refresh server
+            if (schemaRefreshServer) {
+              schemaRefreshServer.stop()
+            }
+            schemaRefreshServer = servers.schemaRefreshServer
+            // Notify clients about schema change
+            schemaRefreshServer.notifySchemaChange()
             await prevApolloServer.stop()
           }
         }