@resolveio/server-lib 22.3.140 → 22.3.142

package/tests/resolveio-platform-intelligence.test.ts

@@ -0,0 +1,352 @@
+import {
+	buildResolveIOPlatformIntelligenceSystemPrompt,
+	getResolveIOPlatformDurableMemoryEntries,
+	getResolveIOPlatformIntelligenceRuleLines,
+	getResolveIOPlatformIntelligenceRuleSections
+} from '../src/ai/resolveio-platform-intelligence';
+import {
+	buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory,
+	hydrateResolveIOPlatformIntelligenceRuleOptions,
+	inferResolveIOPlatformIntelligenceMemoryFamilies,
+	listResolveIOPlatformIntelligenceMemoryEntries
+} from '../src/ai/resolveio-platform-intelligence-memory';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function testCommonRulesIncludeResolveIOContracts() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'builder' });
+	assert(
+		rules.some((rule) => rule.includes('`_id` as a string')),
+		'Expected rules to preserve the ResolveIO string `_id` contract'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-select`')),
+		'Expected rules to prefer `rio-select`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-chart`')),
+		'Expected rules to prefer `rio-chart`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-date-picker`')),
+		'Expected rules to prefer `rio-date-picker`'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not hand-edit generated Angular socket files')),
+		'Expected rules to protect generated methods/publications files'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Never use Mongoose')),
+		'Expected rules to reject Mongoose in ResolveIO platform code'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Never use Meteor')),
+		'Expected rules to reject Meteor in ResolveIO platform code'
+	);
+	assert(
+		rules.some((rule) => rule.includes('ResolveIO `round` helper')),
+		'Expected rules to prefer ResolveIO round helper over Math.round'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Every cited file, symbol, route, collection, workflow, and scoped target must be verified')),
+		'Expected rules to require real path and scope verification'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not use placeholder or fuzzy path language')),
+		'Expected rules to reject placeholder path language'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Map non-technical user wording to internal collections')),
+		'Expected rules to require internal collection/workflow inference from user wording'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not use `*.versions` collections for ordinary requests')),
+		'Expected rules to avoid version collections for ordinary requests'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Company Secrets')),
+		'Expected rules to require Company Secrets for external keys and config'
+	);
+}
+
+function testRioSelectRulesPreferOptionsMode() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'support' });
+	assert(
+		rules.some((rule) => rule.includes('`[options]` pipeline')),
+		'Expected rio-select rules to prefer the `[options]` pipeline'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not mix `[options]` and projected `<rio-option>`')),
+		'Expected rio-select rules to reject mixed mode'
+	);
+	assert(
+		rules.some((rule) => rule.includes('large option sets')),
+		'Expected rio-select rules to mention large-option performance guidance'
+	);
+	assert(
+		rules.some((rule) => rule.includes('distinct-backed options')),
+		'Expected filter rules to prefer distinct-backed dropdown options'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Do not apply Bootstrap `form-control` directly to `rio-select`')),
+		'Expected styling rules to reject form-control on rio-select'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-calendar`')),
+		'Expected rules to prefer rio-calendar for scheduling surfaces'
+	);
+	assert(
+		rules.some((rule) => rule.includes('`rio-pagination`')),
+		'Expected rules to prefer rio-pagination for paginated navigation'
+	);
+	assert(
+		rules.some((rule) => rule.includes('keep them distinct: fix the failing path first')),
+		'Expected rules to keep failing and comparator paths distinct'
+	);
+}
+
+function testBuilderRulesPromoteAppGenerationDiscipline() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'builder' });
+	assert(
+		rules.some((rule) => rule.includes('standard ResolveIO build flow in order')),
+		'Expected builder rules to encode the standard ResolveIO build flow'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Feature modules should normally include module, routing, permission, service')),
+		'Expected builder rules to encode expected feature module structure'
+	);
+	assert(
+		rules.some((rule) => rule.includes('operator command center')),
+		'Expected builder rules to require a tailored dashboard hub'
+	);
+	assert(
+		rules.some((rule) => rule.includes('assistant-heuristics.json')),
+		'Expected builder rules to keep app-level assistant heuristics in sync'
+	);
+	assert(
+		rules.some((rule) => rule.includes('single sign-in entry')),
+		'Expected builder rules to preserve default staff login UX'
+	);
+}
+
+function testAssistantDataRulesPromoteSafeReportBuilderUsage() {
+	const rules = getResolveIOPlatformIntelligenceRuleLines({ mode: 'assistant' });
+	assert(
+		rules.some((rule) => rule.includes('read-only ResolveIO data bridge (`REPORT_BUILDER_READ` / `REPORT_BUILDER_AGG`)')),
+		'Expected rules to prefer the report-builder data bridge for live data'
+	);
+	assert(
+		rules.some((rule) => rule.includes('Always include a verified `permissionView`')),
+		'Expected rules to require verified permissionView for live data queries'
+	);
+	assert(
+		rules.some((rule) => rule.includes('run the smallest safe probe you can')),
+		'Expected rules to require probe validation before concluding no data'
+	);
+	assert(
+		rules.some((rule) => rule.includes('summarize first, then show a clean markdown table')),
+		'Expected rules to require summary-first table output for live data'
+	);
+}
+
+function testDurableMemoryDefaultsAndFiltering() {
+	const defaultEntries = getResolveIOPlatformDurableMemoryEntries({ mode: 'support' });
+	assert(
+		defaultEntries.some((entry) => entry.family === 'rio-select' && entry.kind === 'accepted_pattern'),
+		'Expected default durable memory to include rio-select accepted patterns'
+	);
+	assert(
+		defaultEntries.some((entry) => entry.family === 'shared-library-ownership' && entry.kind === 'rejected_fix_shape'),
+		'Expected default durable memory to include shared-library rejected fix shapes'
+	);
+	assert(
+		defaultEntries.some((entry) => entry.family === 'dashboard-hub' && entry.kind === 'contract_violation'),
+		'Expected default durable memory to include dashboard-hub contract violations'
+	);
+	const filteredEntries = getResolveIOPlatformDurableMemoryEntries({
+		mode: 'support',
+		memoryFamilies: ['rio-select']
+	});
+	assert(filteredEntries.length > 0, 'Expected filtered durable memory to retain rio-select entries');
+	assert(
+		filteredEntries.every((entry) => entry.family === 'rio-select' || (entry.tags || []).includes('rio-select')),
+		'Expected filtered durable memory to stay scoped to the requested family'
+	);
+	assert(
+		!filteredEntries.some((entry) => entry.family === 'dashboard-hub'),
+		'Expected unrelated durable memory families to be excluded by filtering'
+	);
+}
+
+function testPromptCanMergeCustomDurableMemory() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPrompt({
+		mode: 'builder',
+		outputStyle: 'markdown',
+		memoryFamilies: ['rio-select', 'report-builder'],
+		durableMemoryEntries: [
+			{
+				family: 'report-builder',
+				kind: 'accepted_pattern',
+				summary: 'Prefer verified lookup-aware aggregates when grouped metrics span related collections.'
+			}
+		]
+	});
+	assert(prompt.includes('Durable Memory: Accepted Patterns:'), 'Expected durable memory accepted section');
+	assert(prompt.includes('rio-select: Accepted pattern:'), 'Expected prompt to include filtered rio-select durable memory');
+	assert(
+		prompt.includes('report-builder: Accepted pattern: Prefer verified lookup-aware aggregates when grouped metrics span related collections.'),
+		'Expected prompt to include caller-supplied durable memory'
+	);
+	assert(
+		!prompt.includes('dashboard-hub: Contract violation:'),
+		'Expected family filtering to keep unrelated durable memory out of the prompt'
+	);
+}
+
+function testSharedMemorySelectionInfersRelevantFamiliesFromContext() {
+	const families = inferResolveIOPlatformIntelligenceMemoryFamilies('support', [
+		'The rio-select uses [options] with optionLabelFn and is showing a stale selected label after current_location changes.',
+		'This may belong in resolveio-client-lib rather than the app repo.'
+	]);
+	assert(families.includes('rio-select'), 'Expected rio-select family to be inferred from context');
+	assert(
+		families.includes('shared-library-ownership'),
+		'Expected shared-library ownership family to be inferred from library-root-cause context'
+	);
+	const entries = listResolveIOPlatformIntelligenceMemoryEntries({
+		mode: 'support',
+		contextText: [
+			'The rio-select uses [options] with optionLabelFn and is showing a stale selected label after current_location changes.',
+			'This may belong in resolveio-client-lib rather than the app repo.'
+		],
+		limit: 4
+	});
+	assert(entries.length > 0, 'Expected shared memory selection to return relevant entries');
+	assert(
+		entries.some((entry) => entry.family === 'rio-select'),
+		'Expected shared memory selection to include rio-select entries'
+	);
+	assert(
+		entries.some((entry) => entry.family === 'shared-library-ownership'),
+		'Expected shared memory selection to include shared-library ownership entries'
+	);
+}
+
+function testHydrateRuleOptionsUsesRelevantSharedMemoryInsteadOfWholeCorpus() {
+	const hydrated = hydrateResolveIOPlatformIntelligenceRuleOptions(
+		{
+			mode: 'assistant'
+		},
+		{
+			contextText: [
+				'The issue mentions ObjectId assumptions for _id and a direct edit to angular/app/methods.ts.',
+				'We need to keep _id as a string and regenerate generated socket files.'
+			],
+			limit: 5
+		}
+	);
+	assert(hydrated.includeDefaultDurableMemory === false, 'Expected hydrated options to disable full-corpus default injection');
+	const entries = hydrated.durableMemoryEntries || [];
+	assert(
+		entries.some((entry) => entry.family === 'identifier-contract'),
+		'Expected hydrated options to include identifier-contract memory'
+	);
+	assert(
+		entries.some((entry) => entry.family === 'generated-method-publication'),
+		'Expected hydrated options to include generated-method-publication memory'
+	);
+	assert(
+		!entries.some((entry) => entry.family === 'dashboard-hub'),
+		'Expected unrelated memory families to stay out of the hydrated options'
+	);
+}
+
+function testSharedPromptBuilderRendersRelevantCodeBackedMemory() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPromptWithSharedMemory(
+		{
+			mode: 'builder',
+			outputStyle: 'markdown'
+		},
+		{
+			contextText: [
+				'This new app feature needs a real dashboard hub and full feature module wiring.',
+				'Do not leave placeholder quick actions or dead links in the hub.'
+			],
+			limit: 4
+		}
+	);
+	assert(prompt.includes('dashboard-hub: Contract violation:'), 'Expected prompt to include relevant dashboard-hub memory');
+	assert(
+		prompt.includes('feature-module-generation: Accepted pattern:'),
+		'Expected prompt to include relevant feature-module-generation memory'
+	);
+	assert(
+		!prompt.includes('rio-select: Accepted pattern:'),
+		'Expected unrelated rio-select memory to stay out of the shared-memory prompt'
+	);
+}
+
+function testPromptBuildsSectionedVerifyFirstGuidance() {
+	const prompt = buildResolveIOPlatformIntelligenceSystemPrompt({
+		mode: 'assistant',
+		outputStyle: 'markdown',
+		extraRules: ['Always verify the claimed fix with the most relevant local test or reproduction path before finalizing.']
+	});
+	assert(prompt.includes('Investigation Loop:'), 'Expected sectioned investigation loop guidance');
+	assert(prompt.includes('Data And ID Contracts:'), 'Expected sectioned data contract guidance');
+	assert(prompt.includes('Generated Files:'), 'Expected generated file guidance section');
+	assert(prompt.includes('Path Grounding And Scope:'), 'Expected path grounding guidance section');
+	assert(prompt.includes('Collection And Workflow Inference:'), 'Expected collection inference guidance section');
+	assert(prompt.includes('Platform Architecture:'), 'Expected architecture guidance section');
+	assert(prompt.includes('Server Implementation:'), 'Expected server implementation guidance section');
+	assert(prompt.includes('ResolveIO UI Libraries:'), 'Expected sectioned UI library guidance');
+	assert(prompt.includes('App Generation And UX:'), 'Expected app generation guidance section');
+	assert(prompt.includes('Auth And Shell:'), 'Expected auth and shell guidance section');
+	assert(prompt.includes('Shared Library Ownership:'), 'Expected sectioned shared-library guidance');
+	assert(prompt.includes('Live Data And Report Builder:'), 'Expected report builder guidance section');
+	assert(prompt.includes('Durable Memory: Accepted Patterns:'), 'Expected durable memory accepted section');
+	assert(prompt.includes('Durable Memory: Rejected Fix Shapes:'), 'Expected durable memory rejected section');
+	assert(prompt.includes('Durable Memory: Contract Violations:'), 'Expected durable memory contract-violation section');
+	assert(prompt.includes('Build an evidence-to-fix chain:'), 'Expected evidence-to-fix guidance to be rendered');
+	assert(prompt.includes('Always verify the claimed fix with the most relevant local test or reproduction path before finalizing.'), 'Expected extra rules to be appended');
+}
+
+function testSectionsStayDedupedAndModeAware() {
+	const sections = getResolveIOPlatformIntelligenceRuleSections({
+		mode: 'app_terminal',
+		outputStyle: 'plain_english',
+		extraRules: ['Respond with the final user-facing outcome clearly.']
+	});
+	const titles = sections.map((section) => section.title);
+	assert(titles.includes('Mode Rules'), 'Expected mode rules section');
+	assert(titles.includes('Output Style'), 'Expected output style section');
+	assert(
+		sections.some((section) => section.title === 'Mode Rules' && section.rules.some((rule) => rule.includes('plain English'))),
+		'Expected app terminal mode rules to remain present'
+	);
+	assert(
+		sections.some((section) => section.title === 'Extra Rules' && section.rules.includes('Respond with the final user-facing outcome clearly.')),
+		'Expected extra rules section to contain caller-supplied rules'
+	);
+}
+
+function run() {
+	testCommonRulesIncludeResolveIOContracts();
+	testRioSelectRulesPreferOptionsMode();
+	testBuilderRulesPromoteAppGenerationDiscipline();
+	testAssistantDataRulesPromoteSafeReportBuilderUsage();
+	testDurableMemoryDefaultsAndFiltering();
+	testPromptCanMergeCustomDurableMemory();
+	testSharedMemorySelectionInfersRelevantFamiliesFromContext();
+	testHydrateRuleOptionsUsesRelevantSharedMemoryInsteadOfWholeCorpus();
+	testSharedPromptBuilderRendersRelevantCodeBackedMemory();
+	testPromptBuildsSectionedVerifyFirstGuidance();
+	testSectionsStayDedupedAndModeAware();
+	console.log('resolveio platform intelligence tests passed');
+}
+
+run();

package/tests/server-app-cron-owner.test.ts

@@ -0,0 +1,127 @@
+import { ResolveIOMainServer } from '../src/server-app';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+const ENV_KEYS = [
+	'WORKER_INDEX',
+	'NODE_APP_INSTANCE',
+	'SERVER_MANAGER_WORKER_INDEX',
+	'SERVER_MANAGER_WORKER_INSTANCE',
+	'SERVER_MANAGER_NODE_APP_INSTANCE'
+];
+
+function withEnv(env: Record<string, string | undefined>, test: () => void) {
+	const previous: Record<string, string | undefined> = {};
+	for (const key of ENV_KEYS) {
+		previous[key] = process.env[key];
+		delete process.env[key];
+	}
+
+	for (const [key, value] of Object.entries(env)) {
+		if (value !== undefined) {
+			process.env[key] = value;
+		}
+	}
+
+	try {
+		test();
+	}
+	finally {
+		for (const key of ENV_KEYS) {
+			delete process.env[key];
+			if (previous[key] !== undefined) {
+				process.env[key] = previous[key];
+			}
+		}
+	}
+}
+
+function shouldStartCron(): boolean {
+	const server = new ResolveIOMainServer() as any;
+	return server.shouldStartCronManagerForWorker();
+}
+
+async function testStandaloneNodeReaperAlertsAreThrottled() {
+	const server = new ResolveIOMainServer() as any;
+	const proc = {
+		pid: 12345,
+		ppid: 1,
+		ageSeconds: 600,
+		cpuPct: 99,
+		rssKb: 512 * 1024,
+		command: 'node',
+		args: 'node -e while(true){}'
+	};
+	const reports: any[] = [];
+
+	server._standaloneNodeReaperAlertWindowMs = 60 * 60 * 1000;
+	server.resolveProcessCwd = () => '/tmp/resolveio-reaper-test';
+	server.reportServerError = async (...args: any[]) => {
+		reports.push(args);
+	};
+
+	await server.reportStandaloneNodeReaperAction(proc, 'orphan_high_cpu_for_2_scans', 'dry-run');
+	await server.reportStandaloneNodeReaperAction(proc, 'orphan_high_cpu_for_2_scans', 'dry-run');
+	assert(reports.length === 1, 'Expected duplicate dry-run reaper alert to be throttled');
+
+	await server.reportStandaloneNodeReaperAction(proc, 'orphan_high_cpu_for_2_scans', 'terminated');
+	assert(reports.length === 2, 'Expected different reaper action to report independently');
+
+	const alertKey = `dry-run|${server.resolveStandaloneNodeProcessSignature(proc)}`;
+	server._standaloneNodeReaperAlertTimes.set(alertKey, Date.now() - server._standaloneNodeReaperAlertWindowMs - 1);
+	await server.reportStandaloneNodeReaperAction(proc, 'orphan_high_cpu_for_2_scans', 'dry-run');
+	assert(reports.length === 3, 'Expected reaper alert to report again after throttle window');
+}
+
+async function run() {
+	withEnv({ WORKER_INDEX: '0', NODE_APP_INSTANCE: '0' }, () => {
+		assert(shouldStartCron() === true, 'Expected default worker 0 to start cron');
+	});
+
+	withEnv({ WORKER_INDEX: '1', NODE_APP_INSTANCE: '0' }, () => {
+		assert(shouldStartCron() === false, 'Expected default non-zero worker to skip cron');
+	});
+
+	withEnv({
+		WORKER_INDEX: '0',
+		NODE_APP_INSTANCE: '0',
+		SERVER_MANAGER_WORKER_INDEX: '0',
+		SERVER_MANAGER_WORKER_INSTANCE: '1'
+	}, () => {
+		assert(shouldStartCron() === false, 'Expected publication worker to skip ResolveIO server-manager cron');
+	});
+
+	withEnv({
+		WORKER_INDEX: '0',
+		NODE_APP_INSTANCE: '1',
+		SERVER_MANAGER_WORKER_INDEX: '0',
+		SERVER_MANAGER_WORKER_INSTANCE: '1'
+	}, () => {
+		assert(shouldStartCron() === true, 'Expected ResolveIO server-manager worker to start cron');
+	});
+
+	withEnv({
+		WORKER_INDEX: '0',
+		NODE_APP_INSTANCE: '0',
+		SERVER_MANAGER_WORKER_INDEX: '0',
+		SERVER_MANAGER_WORKER_INSTANCE: '0'
+	}, () => {
+		assert(shouldStartCron() === true, 'Expected explicit default server-manager owner to preserve cron behavior');
+	});
+
+	await testStandaloneNodeReaperAlertsAreThrottled();
+}
+
+run()
+	.then(() => {
+		console.log('server-app-cron-owner.test.ts passed');
+		process.exit(0);
+	})
+	.catch(error => {
+		console.error(error);
+		process.exit(1);
+	});

package/tests/subscription-connect-race.test.ts

@@ -0,0 +1,158 @@
+import { ResolveIOMainServer } from '../src/server-app';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function sleep(ms: number) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+class FakeWebSocket {
+	public readyState = 1;
+	public closed = false;
+	public sent: any[] = [];
+	private _handlers = new Map<string, Function>();
+
+	on(event: string, handler: Function) {
+		this._handlers.set(event, handler);
+		return this;
+	}
+
+	send(data: any, cb?: (error?: Error) => void) {
+		this.sent.push(data);
+		if (cb) {
+			cb();
+		}
+	}
+
+	ping() {
+		// noop
+	}
+
+	close() {
+		this.closed = true;
+	}
+
+	getHandler(event: string): Function | undefined {
+		return this._handlers.get(event);
+	}
+}
+
+async function testConnectionHandlerDoesNotBlockOnLoggedInUserInsert() {
+	const server = new ResolveIOMainServer();
+	const serverAny = server as any;
+
+	let connectionHandler: ((ws: FakeWebSocket, req: any) => Promise<void>) | null = null;
+	let createLoggedInUserCalled = false;
+
+	let resolveCreateLoggedInUser: () => void = null;
+	const createLoggedInUserPromise = new Promise<void>(resolve => {
+		resolveCreateLoggedInUser = resolve;
+	});
+
+	serverAny._portHTTP = 8080;
+	serverAny._clientHeartbeatInitialDelayMs = 1;
+	serverAny._methodManager = {
+		getEnableDebug: () => false,
+		_methods: {}
+	};
+	serverAny._subscriptionManager = {
+		createLoggedInUser: () => {
+			createLoggedInUserCalled = true;
+			return createLoggedInUserPromise;
+		},
+		loggedInLatency: () => {},
+		unsubscribeAll: async () => {},
+		subscribe: async () => {},
+		unsubscribe: () => {}
+	};
+	serverAny._websocketManager = {
+		addWebSocket: () => {},
+		getWebSocket: () => null,
+		send: () => {}
+	};
+	serverAny._workerDispatcherManager = {
+		addWorker: () => {},
+		disconnectWorker: () => {},
+		sendWorkerPayload: () => {},
+		handleWorkerMessage: () => {}
+	};
+	serverAny._clientRoutes = [];
+	serverAny.publicProgram = false;
+	serverAny.LOGGER = 'ERROR';
+	serverAny.triggerClientHeartbeat = async () => {};
+	serverAny.unsubscribeWS = async () => {};
+	serverAny._serverHTTP = {
+		listen: (_port: number, _host: string, cb: () => void) => cb()
+	};
+	serverAny._serverWSS = {
+		clients: new Set(),
+		on: (event: string, handler: any) => {
+			if (event === 'connection') {
+				connectionHandler = handler;
+			}
+		}
+	};
+
+	const originalSetInterval = global.setInterval;
+	(global as any).setInterval = (() => 0) as any;
+
+	try {
+		serverAny.listen();
+
+		assert(typeof connectionHandler === 'function', 'Expected WS connection handler registration');
+
+		const ws = new FakeWebSocket();
+		const req = {
+			url: '/',
+			id_user: 'user-1',
+			user: 'Test User',
+			user_readonly: false,
+			doc_user: {
+				roles: {
+					groups: [],
+					super_admin: true
+				}
+			},
+			socket: {
+				remoteAddress: '127.0.0.1'
+			},
+			headers: {
+				origin: 'http://localhost:4200'
+			}
+		};
+
+		const connectionResult = await Promise.race([
+			connectionHandler(ws, req).then(() => 'resolved'),
+			sleep(100).then(() => 'timed_out')
+		]);
+
+		assert(connectionResult === 'resolved', 'Connection handler blocked on createLoggedInUser');
+		await sleep(0);
+		assert(createLoggedInUserCalled, 'Expected createLoggedInUser to be called');
+		assert(typeof ws.getHandler('message') === 'function', 'Expected message handler registered immediately');
+
+		const messageHandler = ws.getHandler('message') as (message: any) => Promise<void>;
+		await messageHandler('ping');
+		assert(ws.sent.includes('pong'), 'Expected ping message to be handled immediately after connection');
+
+		resolveCreateLoggedInUser();
+	}
+	finally {
+		global.setInterval = originalSetInterval;
+	}
+}
+
+async function run() {
+	await testConnectionHandlerDoesNotBlockOnLoggedInUserInsert();
+	console.log('subscription-connect-race tests completed');
+	process.exit(0);
+}
+
+run().catch(error => {
+	console.error(error);
+	process.exit(1);
+});