TML-2984: surface config-load failures and retain the last-good project

A failed project load publishes one diagnostic on the config-file URI
at document start (push channel unconditionally -- the config file
belongs to the TypeScript language service, so pull never reaches us),
cleared on the next successful load or when the project is dropped for
document-lifecycle reasons. The loading entry now carries the previous
ProjectState: a broken reload restores it so open schema documents keep
their parse, symbol-table, and interpreter diagnostics, while a failed
first load keeps todays no-project behavior. Superseded loads stay
silent.

Signed-off-by: Serhii Tatarintsev <tatarintsev@prisma.io>

Author: SevInf

packages/1-framework/3-tooling/language-server/src/server.ts

@@ -1,4 +1,4 @@
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { findNearestConfigPathForFile } from '@prisma-next/config-loader';
 import type { SymbolTable } from '@prisma-next/psl-parser';
 import { type FormatOptions, format } from '@prisma-next/psl-parser/format';
@@ -75,20 +75,25 @@ type ManagedProject =
       readonly status: 'loading';
       readonly load: Promise<ProjectState>;
       /**
-       * Whether a loaded project existed when this load (chain) began — a
-       * failed reload must still clear the markers push clients were shown,
-       * while a failed first load must not publish anything.
+       * The project that was loaded when this load (chain) began. A failed
+       * reload restores it — a broken config edit must not destroy a working
+       * project — while a failed first load (no last-good) publishes nothing
+       * and leaves documents unmanaged.
        */
-      readonly hadLoadedProject: boolean;
+      readonly lastGood: ProjectState | undefined;
     }
   | { readonly status: 'loaded'; readonly project: ProjectState };
 
+const CONFIG_LOAD_FAILED_CODE = 'PRISMA_NEXT_CONFIG_LOAD_FAILED';
+
 const semanticTokenSourceLimit = 100_000;
 
 export function createServer(connection: Connection): LanguageServer {
   const documents = new TextDocuments(TextDocument);
   const managedProjects = new Map<string, ManagedProject>();
   const documentConfigPaths = new Map<string, string>();
+  // Config-file URIs with a currently published load-failure diagnostic.
+  const configFailureUris = new Map<string, string>();
   let rootPath = process.cwd();
   let watchedConfigGlob = join(rootPath, '**', CONFIG_FILENAME);
   let clientCapabilities = noClientCapabilities;
@@ -217,34 +222,78 @@ export function createServer(connection: Connection): LanguageServer {
 
   // A load replaces the entry with `loading` immediately, so reads during a
   // config reload await the fresh resolution instead of the pre-reload
-  // project. A failed load leaves its entry in place — every awaiter funnels
-  // the failure into `stopManagingProject`, which needs the entry to decide
-  // whether push clears are owed.
+  // project. A failed first load leaves its entry in place — every awaiter
+  // funnels the failure into `stopManagingProject` — while a failed reload
+  // restores the last-good project so open documents keep being served.
   function startProjectLoad(configPath: string): Promise<ProjectState> {
     const existing = managedProjects.get(configPath);
     const previousLoad = existing?.status === 'loading' ? existing.load : undefined;
-    const hadLoadedProject =
-      existing?.status === 'loaded' ||
-      (existing?.status === 'loading' && existing.hadLoadedProject);
+    const lastGood =
+      existing?.status === 'loaded'
+        ? existing.project
+        : existing?.status === 'loading'
+          ? existing.lastGood
+          : undefined;
     const load: Promise<ProjectState> = (previousLoad ?? Promise.resolve(undefined))
       .catch(() => undefined)
       .then(() => loadProject(configPath))
-      .then((project) => {
-        // A load that outlives the last association must not keep a project
-        // entry alive.
-        if (isCurrentLoad(configPath, load)) {
-          if (hasManagedDocuments(configPath)) {
-            managedProjects.set(configPath, { status: 'loaded', project });
-          } else {
-            managedProjects.delete(configPath);
+      .then(
+        (project) => {
+          // A load that outlives the last association must not keep a project
+          // entry alive.
+          if (isCurrentLoad(configPath, load)) {
+            if (hasManagedDocuments(configPath)) {
+              managedProjects.set(configPath, { status: 'loaded', project });
+            } else {
+              managedProjects.delete(configPath);
+            }
+            clearConfigFailure(configPath);
           }
-        }
-        return project;
-      });
-    managedProjects.set(configPath, { status: 'loading', load, hadLoadedProject });
+          return project;
+        },
+        (error: unknown) => {
+          // Only the current load's outcome speaks; superseded failures stay
+          // silent.
+          if (isCurrentLoad(configPath, load)) {
+            publishConfigFailure(configPath, error);
+            if (lastGood !== undefined) {
+              managedProjects.set(configPath, { status: 'loaded', project: lastGood });
+              return lastGood;
+            }
+          }
+          throw error;
+        },
+      );
+    managedProjects.set(configPath, { status: 'loading', load, lastGood });
     return load;
   }
 
+  function publishConfigFailure(configPath: string, error: unknown): void {
+    const uri = pathToFileURL(configPath).toString();
+    configFailureUris.set(configPath, uri);
+    sendDiagnostics({
+      uri,
+      diagnostics: [
+        {
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+          message: error instanceof Error ? error.message : String(error),
+          code: CONFIG_LOAD_FAILED_CODE,
+          severity: DiagnosticSeverity.Error,
+          source: 'prisma-next',
+        },
+      ],
+    });
+  }
+
+  function clearConfigFailure(configPath: string): void {
+    const uri = configFailureUris.get(configPath);
+    if (uri === undefined) {
+      return;
+    }
+    configFailureUris.delete(configPath);
+    sendDiagnostics({ uri, diagnostics: [] });
+  }
+
   function isCurrentLoad(configPath: string, load: Promise<ProjectState>): boolean {
     const entry = managedProjects.get(configPath);
     return entry?.status === 'loading' && entry.load === load;
@@ -276,10 +325,14 @@ export function createServer(connection: Connection): LanguageServer {
     return project;
   }
 
+  // Callers are the failed-load funnels — the config-failure marker must
+  // survive this drop so a broken config stays visible; it clears on the
+  // next successful load or when the config's project is dropped for
+  // document-lifecycle reasons (dropProjectWithoutManagedDocuments).
   function stopManagingProject(configPath: string): void {
     const entry = managedProjects.get(configPath);
     const hadProject =
-      entry?.status === 'loaded' || (entry?.status === 'loading' && entry.hadLoadedProject);
+      entry?.status === 'loaded' || (entry?.status === 'loading' && entry.lastGood !== undefined);
     managedProjects.delete(configPath);
     for (const document of documents.all()) {
       if (documentConfigPaths.get(document.uri) === configPath) {
@@ -597,6 +650,7 @@ export function createServer(connection: Connection): LanguageServer {
     if (managedProjects.get(configPath)?.status === 'loaded') {
       managedProjects.delete(configPath);
     }
+    clearConfigFailure(configPath);
   }
 
   return {

packages/1-framework/3-tooling/language-server/test/server.test.ts

@@ -1671,23 +1671,26 @@ describe('language server config watching', { timeout: timeouts.databaseOperatio
     expect((await diagnosed).length).toBeGreaterThan(0);
   });
 
-  it('stops managing a project when a config edit breaks the config', async () => {
+  it('keeps serving the last-good project when a config edit breaks the config', async () => {
     const hook = mutableResolve(resolveToSchema);
     harness = startHarness(hook.resolve, watchedFilesCapabilities);
     await harness.initialize();
 
     harness.client.sendNotification(DidOpenTextDocumentNotification.type, {
       textDocument: { uri: schemaUri, languageId: 'prisma', version: 1, text: 'model {' },
     });
-    expect((await harness.waitForDiagnostics(schemaUri)).length).toBeGreaterThan(0);
+    const before = await harness.waitForDiagnostics(schemaUri);
+    expect(before.length).toBeGreaterThan(0);
 
-    const cleared = harness.waitForDiagnosticsMatching(
-      schemaUri,
-      (diagnostics) => diagnostics.length === 0,
-    );
     hook.set(resolveFails);
     harness.notifyConfigChanged();
-    expect(await cleared).toEqual([]);
+
+    // The broken reload surfaces on the config file; the schema keeps its
+    // last-good diagnostics instead of being cleared.
+    const configDiagnostics = await harness.waitForDiagnostics(configUri);
+    expect(configDiagnostics).toHaveLength(1);
+    await settle();
+    expect(harness.latestDiagnostics(schemaUri)).toEqual(before);
   });
 });
 
@@ -2214,3 +2217,179 @@ describe('language server interpreter diagnostics', { timeout: timeouts.database
     expect(spy).toHaveBeenCalledTimes(2);
   });
 });
+
+describe('language server config failure surfacing', {
+  timeout: timeouts.databaseOperation,
+}, () => {
+  const cleanSchema = 'model User {\n  id Int @id\n}\n';
+  const expectedConfigFailure = (message: string): Diagnostic => ({
+    range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+    message,
+    code: 'PRISMA_NEXT_CONFIG_LOAD_FAILED',
+    severity: DiagnosticSeverity.Error,
+    source: 'prisma-next',
+  });
+
+  function interpretingResolution(): ConfigResolution {
+    const source = {
+      sourceFormat: 'psl',
+      inputs: [schemaPath],
+      load: async () => ok({} as never),
+      interpret: () =>
+        notOk({
+          summary: 'Schema has 1 error',
+          diagnostics: [{ code: 'PSL_INTERPRETER_FINDING', message: 'finding' }],
+        }),
+    } as unknown as PslInterpretCapable;
+    return {
+      ...resolutionForInputs([schemaPath]),
+      interpretation: { source, context: {} as unknown as ContractSourceContext },
+    };
+  }
+
+  it('publishes one config diagnostic on first-load failure and leaves the document unmanaged', async () => {
+    harness = startHarness(async () => {
+      throw new Error('config exploded');
+    });
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+
+    const published = await harness.waitForDiagnostics(configUri);
+    expect(published).toEqual([expectedConfigFailure('config exploded')]);
+    expect(harness.getDocumentAst(schemaUri)).toBeUndefined();
+
+    // The marker persists after the failed load settles.
+    await settle();
+    expect(harness.latestDiagnostics(configUri)).toEqual([
+      expectedConfigFailure('config exploded'),
+    ]);
+  });
+
+  it('publishes the config diagnostic exactly once when two documents await the same load', async () => {
+    const otherPath = join(root, 'other.psl');
+    const otherUri = pathToFileURL(otherPath).toString();
+    const gate = deferredSettleable<ConfigResolution>();
+    harness = startHarness(() => gate.promise);
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+    openDocument(harness, otherUri, cleanSchema);
+    // Both open notifications are processed before the shared load settles.
+    await settle();
+    gate.reject(new Error('config exploded'));
+
+    await harness.waitForDiagnostics(configUri);
+    await settle();
+    expect(harness.publishCount(configUri)).toBe(1);
+  });
+
+  it('publishes the config diagnostic even for pull-capable clients', async () => {
+    harness = startHarness(async () => {
+      throw new Error('config exploded');
+    }, pullDiagnosticsCapabilities);
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+    // Pull clients trigger project resolution through the pull request; the
+    // config failure must still arrive on the push channel.
+    const report = await requestPullDiagnostics(harness, schemaUri);
+    expect(fullReportItems(report)).toEqual([]);
+
+    const published = await harness.waitForDiagnostics(configUri);
+    expect(published).toEqual([expectedConfigFailure('config exploded')]);
+  });
+
+  it('clears the config diagnostic on the next successful load', async () => {
+    let failures = 1;
+    harness = startHarness(async () => {
+      if (failures > 0) {
+        failures -= 1;
+        throw new Error('config exploded');
+      }
+      return resolutionForInputs([schemaPath]);
+    });
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+    await harness.waitForDiagnostics(configUri);
+
+    harness.notifyConfigChanged();
+
+    await harness.waitForDiagnosticsMatching(configUri, (diagnostics) => diagnostics.length === 0);
+    expect(harness.latestDiagnostics(configUri)).toEqual([]);
+  });
+
+  it('keeps serving the last-good project through a broken reload, then swaps in the fix', async () => {
+    let mode: 'good' | 'broken' | 'fixed' = 'good';
+    harness = startHarness(async () => {
+      if (mode === 'broken') {
+        throw new Error('config exploded');
+      }
+      return interpretingResolution();
+    }, pullDiagnosticsCapabilities);
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+
+    const before = await requestPullDiagnostics(harness, schemaUri);
+    expect(fullReportItems(before).map((d) => d.code)).toContain('PSL_INTERPRETER_FINDING');
+
+    mode = 'broken';
+    harness.notifyConfigChanged();
+    const failure = await harness.waitForDiagnostics(configUri);
+    expect(failure).toEqual([expectedConfigFailure('config exploded')]);
+
+    const retained = await requestPullDiagnostics(harness, schemaUri);
+    expect(fullReportItems(retained).map((d) => d.code)).toContain('PSL_INTERPRETER_FINDING');
+
+    mode = 'fixed';
+    harness.notifyConfigChanged();
+    await harness.waitForDiagnosticsMatching(configUri, (diagnostics) => diagnostics.length === 0);
+
+    const after = await requestPullDiagnostics(harness, schemaUri);
+    expect(fullReportItems(after).map((d) => d.code)).toContain('PSL_INTERPRETER_FINDING');
+  });
+
+  it('clears the config diagnostic when the last managed document closes', async () => {
+    // A retained last-good project dropped by its final document close must
+    // not leave a zombie config marker behind.
+    let broken = false;
+    harness = startHarness(async () => {
+      if (broken) {
+        throw new Error('config exploded');
+      }
+      return resolutionForInputs([schemaPath]);
+    });
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+    await harness.waitForDiagnostics(schemaUri);
+
+    broken = true;
+    harness.notifyConfigChanged();
+    await harness.waitForDiagnostics(configUri);
+
+    harness.client.sendNotification(DidCloseTextDocumentNotification.type, {
+      textDocument: { uri: schemaUri },
+    });
+
+    await harness.waitForDiagnosticsMatching(configUri, (diagnostics) => diagnostics.length === 0);
+  });
+
+  it('stays silent for a superseded load failure', async () => {
+    const first = deferredSettleable<ConfigResolution>();
+    let call = 0;
+    harness = startHarness(() => {
+      call += 1;
+      return call === 1 ? first.promise : Promise.resolve(resolutionForInputs([schemaPath]));
+    });
+    await harness.initialize();
+    openDocument(harness, schemaUri, cleanSchema);
+
+    harness.notifyConfigChanged();
+    // The watched-config handler swaps the current load synchronously before
+    // its first await; settling lets that notification dispatch, so the
+    // rejection below lands on a superseded load.
+    await settle();
+    first.reject(new Error('superseded failure'));
+
+    await harness.waitForDiagnostics(schemaUri);
+    await settle();
+    expect(harness.publishCount(configUri)).toBe(0);
+  });
+});