fix(openapi): restore empty-resources guard to prevent job-worker early reply

Without the guard a job-type worker (resources.size === 0) responds to
RESOURCE_OPENAPI_REQUEST before an app worker, silently returning an empty
spec — identical to the original bug (#299).

Restores the early-return guard so only a worker that actually owns resources
replies. When no worker has resources the caller receives a 503 after the
timeout, which is more honest than an empty spec.

Also fixes the unit tests to properly exercise the guard and the happy-path:
- 'does not respond when this thread has no registered resources' verifies the guard
- Send/drop tests populate the resources map with a minimal skippable entry
  (isError: true) so Resources.set() wraps it correctly for generateJsonApi

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: kriszyp

server/itc/serverHandlers.js

@@ -172,6 +172,11 @@ async function resourceOpenApiRequestHandler(event) {
 		hdbLogger.trace(`ITC resourceOpenApiRequestHandler received request:`, event);
 
 		const { resources } = require('../../resources/Resources.ts');
+		// Only respond if this thread has registered resources. Job-type workers with an empty
+		// resources map must stay silent so that an app worker with real resources replies first.
+		// If no worker has resources the main thread gets a 503 after the timeout, which is a
+		// more honest response than silently returning an empty spec.
+		if (!resources || resources.size === 0) return;
 		const { generateJsonApi } = require('../../resources/openApi.ts');
 		const openapi = generateJsonApi(resources, event.message.serverHttpURL);
 

unitTests/server/itc/serverHandlers.test.js

@@ -225,12 +225,15 @@ describe('Test hdbChildIpcHandler module', () => {
 
 	describe('Test resourceOpenApiRequestHandler function', () => {
 		let resource_openapi_handler;
+		let resources_instance;
 
 		before(() => {
 			resource_openapi_handler = server_itc_handlers.__get__('resourceOpenApiRequestHandler');
-			// Ensure the module-level `resources` export is an initialised Resources instance
-			// (not undefined) so generateJsonApi can iterate over it safely.
-			resetResources();
+			resources_instance = resetResources();
+		});
+
+		afterEach(() => {
+			resources_instance.clear();
 		});
 
 		// Tests validation: invalid events should be rejected and logged
@@ -261,7 +264,9 @@ describe('Test hdbChildIpcHandler module', () => {
 			expect(log_error_stub).to.have.been.called;
 		});
 
-		it('sends OpenAPI response directly when originator is reachable', async () => {
+		// Tests guard: a thread with no registered resources must stay silent so that an app
+		// worker (which has real resources) responds first and the caller gets the correct spec.
+		it('does not respond when this thread has no registered resources', async () => {
 			sandbox.resetHistory();
 			const sendToThreadStub = sandbox.stub(global.threads, 'sendToThread').returns(true);
 
@@ -271,36 +276,37 @@ describe('Test hdbChildIpcHandler module', () => {
 			};
 			await resource_openapi_handler(test_event);
 
-			expect(sendToThreadStub).to.have.been.calledOnce;
-			expect(sendToThreadStub.firstCall.args[0]).to.equal(5);
-			const responseMessage = sendToThreadStub.firstCall.args[1];
-			expect(responseMessage.type).to.equal('resource_openapi_response');
-			expect(responseMessage.message.requestId).to.equal(99);
-			expect(responseMessage.message.openapi).to.be.an('object');
+			expect(sendToThreadStub).to.not.have.been.called;
 			expect(log_error_stub).to.not.have.been.called;
 			sendToThreadStub.restore();
 		});
 
-		it('sends OpenAPI response even when resources map is empty (no hang)', async () => {
+		it('sends OpenAPI response directly when originator is reachable', async () => {
 			sandbox.resetHistory();
+			// Resources.set wraps the argument as entry.Resource; passing {isError:true} makes
+			// generateJsonApi skip the entry so the spec is minimal but the send path is exercised.
+			resources_instance.set('test', { isError: true });
 			const sendToThreadStub = sandbox.stub(global.threads, 'sendToThread').returns(true);
 
 			const test_event = {
 				type: 'resource_openapi_request',
-				message: { originator: 5, requestId: 100, serverHttpURL: 'http://localhost:9925' },
+				message: { originator: 5, requestId: 99, serverHttpURL: 'http://localhost:9925' },
 			};
 			await resource_openapi_handler(test_event);
 
-			// Worker always responds — caller gets a spec (possibly empty) rather than a 5s timeout
 			expect(sendToThreadStub).to.have.been.calledOnce;
-			expect((responseMessage) => responseMessage.message.openapi).to.be.a('function');
+			expect(sendToThreadStub.firstCall.args[0]).to.equal(5);
 			const responseMessage = sendToThreadStub.firstCall.args[1];
+			expect(responseMessage.type).to.equal('resource_openapi_response');
+			expect(responseMessage.message.requestId).to.equal(99);
 			expect(responseMessage.message.openapi).to.be.an('object');
+			expect(log_error_stub).to.not.have.been.called;
 			sendToThreadStub.restore();
 		});
 
 		it('drops response silently when originator is unreachable', async () => {
 			sandbox.resetHistory();
+			resources_instance.set('test', { isError: true });
 			const sendToThreadStub = sandbox.stub(global.threads, 'sendToThread').returns(false);
 
 			const test_event = {