@resolveio/server-lib 22.2.33 → 22.2.34

package/tests/error-reporter.test.ts

@@ -0,0 +1,145 @@
+import { ResolveIOServer } from '../src/resolveio-server-app';
+import { ErrorReporter } from '../src/util/error-reporter';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function setServerConfig(overrides: Record<string, any> = {}) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny._serverConfig = Object.assign({
+		CLIENT_NAME: 'TestClient',
+		ROOT_URL: 'https://test.resolveio.com',
+		SERVER_URL: 'https://backend.resolveio.com'
+	}, overrides);
+	serverAny._client = 'test-client';
+}
+
+function setAutoFixManager(manager: any) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny.AutoFixManager = manager;
+}
+
+async function testSuccessfulLocalIngest() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invoice close failed',
+		context: {foo: 'bar'}
+	});
+
+	assert(result.delivered === true, 'Expected report to be delivered');
+	assert(result.status === 200, 'Expected local status code');
+	assert(result.reason === 'queued', 'Expected ingest status to propagate');
+	assert(payloadSnapshot !== null, 'Expected payload to be ingested');
+	assert(payloadSnapshot.message === 'Invoice close failed', 'Expected message in payload');
+	assert(payloadSnapshot.sourceApp === 'unit-test', 'Expected sourceApp in payload');
+	assert(payloadSnapshot.context.foo === 'bar', 'Expected context payload');
+	assert(typeof payloadSnapshot.fingerprint === 'string' && payloadSnapshot.fingerprint.length > 0, 'Expected fingerprint');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected reportedAt to be a Date');
+}
+
+async function testManagerMissing() {
+	setServerConfig();
+	setAutoFixManager(null);
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail without manager'
+	});
+
+	assert(result.delivered === false, 'Expected local manager missing failure');
+	assert(result.reason === 'local-manager-missing', 'Expected local-manager-missing reason');
+}
+
+async function testManagerNotReady() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => false,
+		ingestErrorReport: async () => ({status: 'queued'})
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail when manager not ready'
+	});
+
+	assert(result.delivered === false, 'Expected manager not-ready failure');
+	assert(result.reason === 'local-manager-not-ready', 'Expected local-manager-not-ready reason');
+}
+
+async function testManagerIngestFailure() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async () => {
+			throw new Error('ingest boom');
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail on ingest error'
+	});
+
+	assert(result.delivered === false, 'Expected local ingest failure');
+	assert(result.reason === 'local-ingest-failed', 'Expected local-ingest-failed reason');
+}
+
+async function testInvalidDateSerializationDoesNotThrow() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invalid date handling',
+		context: {
+			badDate: new Date('not-a-date'),
+			okDate: new Date('2024-01-01T00:00:00.000Z')
+		},
+		reportedAt: new Date('not-a-date')
+	});
+
+	assert(payloadSnapshot !== null, 'Expected payload snapshot for invalid date test');
+	assert(payloadSnapshot.context.badDate === null, 'Expected invalid date to serialize as null');
+	assert(payloadSnapshot.context.okDate === '2024-01-01T00:00:00.000Z', 'Expected valid date to serialize normally');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected fallback reportedAt as Date');
+}
+
+async function run() {
+	try {
+		await testSuccessfulLocalIngest();
+		await testManagerMissing();
+		await testManagerNotReady();
+		await testManagerIngestFailure();
+		await testInvalidDateSerializationDoesNotThrow();
+		console.log('error reporter tests passed');
+	}
+	finally {
+		setAutoFixManager(null);
+	}
+}
+
+run().catch(err => {
+	console.error('error reporter tests failed');
+	console.error(err);
+	process.exit(1);
+});

package/tests/report-builder-linking.test.ts

@@ -0,0 +1,79 @@
+import { applyLinkFieldUnwinds } from '../src/util/report-builder-unwinds';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function countUnwinds(query: any[], path: string) {
+	return query.filter(stage => stage?.$unwind?.path === path).length;
+}
+
+function countLookups(query: any[], as: string) {
+	return query.filter(stage => stage?.$lookup?.as === as).length;
+}
+
+function testAddsMissingUnwindsForLinkedLookupArrayField() {
+	const query: any[] = [];
+	const sizes: string[] = [];
+
+	const lookupAsRaw = 'items.$.wo_details.$.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+	const lookupAs = 'items.wo_details.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+
+	const fieldFirst = lookupAsRaw + '.$.chemicals.$.id_chemical';
+	const fieldSecond = 'items.$.id_chemical';
+
+	const selectedFields = [
+		{
+			fieldPath: fieldFirst,
+			lookup_collection: 'work-order-dynamics',
+			lookup_local_key: 'items.wo_details.id_wo',
+			lookup_foreign_key: '_id',
+			lookup_as: lookupAsRaw
+		},
+		{
+			fieldPath: fieldSecond,
+			lookup_collection: '',
+			lookup_local_key: '',
+			lookup_foreign_key: '',
+			lookup_as: ''
+		}
+	];
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(countLookups(query, lookupAs) === 1, 'Expected lookup stage for linked lookup field');
+	assert(countUnwinds(query, '$items') === 1, 'Expected unwind for items');
+	assert(countUnwinds(query, '$items.wo_details') === 1, 'Expected unwind for items.wo_details');
+	assert(countUnwinds(query, '$' + lookupAs) === 1, 'Expected unwind for lookup results');
+	assert(countUnwinds(query, '$' + lookupAs + '.chemicals') === 1, 'Expected unwind for lookup chemicals array');
+
+	const originalLength = query.length;
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(query.length === originalLength, 'Expected second call to be idempotent');
+}
+
+function run() {
+	testAddsMissingUnwindsForLinkedLookupArrayField();
+	console.log('report builder linking tests passed');
+}
+
+run();
+

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

@@ -0,0 +1,157 @@
+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');
+		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);
+});

package/tests/subscription-dependency-context.test.ts

@@ -0,0 +1,324 @@
+import { recordAggregateDependencies, recordDependencyResult, withDependencyTracking } from '../src/util/subscription-dependency-context';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+async function testTracksIdsFromResults() {
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordDependencyResult('primary', [
+			{ _id: 'A' },
+			{ _id: 'B' },
+			{ _id: { toString: () => 'C' } }
+		]);
+	});
+
+	const primary = snapshot.dependencies.get('primary');
+
+	assert(primary instanceof Set, 'Expected dependency set for primary collection');
+	assert(primary.size === 3, 'Expected three tracked ids for primary collection');
+	assert(primary.has('A') && primary.has('B') && primary.has('C'), 'Tracked ids missing expected values');
+}
+
+async function testFallsBackToWatchAllWithoutIds() {
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordDependencyResult('no-ids', [{ foo: 'bar' }]);
+	});
+
+	assert(snapshot.watchAllCollections.has('no-ids'), 'Expected no-ids collection marked as watch-all');
+}
+
+async function testCollectsLookupDependencies() {
+	const pipeline = [
+		{
+			$lookup: {
+				from: 'secondary',
+				localField: 'id_secondary',
+				foreignField: '_id',
+				as: 'secondaryDocs'
+			}
+		}
+	];
+
+	const result = [
+		{
+			_id: 'P1',
+			secondaryDocs: [
+				{ _id: 'S1' },
+				{ _id: { toHexString: () => 'S2' } }
+			]
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('primary', pipeline, result);
+	});
+
+	const primary = snapshot.dependencies.get('primary');
+	const secondary = snapshot.dependencies.get('secondary');
+
+	assert(primary?.has('P1'), 'Expected primary dependency to include P1');
+	assert(secondary?.has('S1'), 'Expected secondary dependency to include S1');
+	assert(secondary?.has('S2'), 'Expected secondary dependency to include S2');
+}
+
+async function testLookupFilterStoredWhenNoMatches() {
+	const pipeline = [
+		{
+			$lookup: {
+				from: 'secondary',
+				localField: 'id_secondary',
+				foreignField: 'id_parent',
+				as: 'secondaryDocs'
+			}
+		}
+	];
+
+	const result = [
+		{
+			_id: 'P1',
+			id_secondary: ['X1', 'X2'],
+			secondaryDocs: []
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('primary', pipeline, result);
+	});
+
+	const filters = snapshot.filters.get('secondary');
+
+	assert(filters && filters.length === 1, 'Expected one filter stored for secondary collection');
+	assert(filters[0].id_parent && Array.isArray(filters[0].id_parent.$in), 'Expected filter to use $in on id_parent');
+	assert(filters[0].id_parent.$in.includes('X1'), 'Expected filter to include X1');
+	assert(filters[0].id_parent.$in.includes('X2'), 'Expected filter to include X2');
+	assert(!snapshot.watchAllCollections.has('secondary'), 'Expected secondary collection not marked as watch-all');
+}
+
+async function testMatchFilterCapturedForPrimary() {
+	const pipeline = [
+		{
+			$match: {
+				status: 'Active',
+				id_customer: { $in: ['C1', 'C2'] }
+			}
+		},
+		{
+			$lookup: {
+				from: 'secondary',
+				localField: 'id_secondary',
+				foreignField: '_id',
+				as: 'secondaryDocs'
+			}
+		}
+	];
+
+	const result = [
+		{
+			_id: 'P1',
+			status: 'Active',
+			id_customer: 'C1',
+			secondaryDocs: []
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('primary', pipeline, result);
+	});
+
+	const filters = snapshot.filters.get('primary');
+
+	assert(filters && filters.length === 1, 'Expected one filter stored for primary collection');
+	const storedFilter = filters[0];
+	assert(storedFilter.status === 'Active', 'Expected status to be Active in stored filter');
+	assert(storedFilter.id_customer && Array.isArray(storedFilter.id_customer.$in), 'Expected id_customer filter to use $in');
+	assert(storedFilter.id_customer.$in.includes('C1'), 'Expected filter to include C1');
+	assert(storedFilter.id_customer.$in.includes('C2'), 'Expected filter to include C2');
+}
+
+async function testMatchFilterIgnoresLookupAliases() {
+	const pipeline = [
+		{
+			$match: {
+				type: 'Truck Treat'
+			}
+		},
+		{
+			$lookup: {
+				from: 'bols',
+				localField: 'id_bol',
+				foreignField: '_id',
+				as: 'bol'
+			}
+		},
+		{
+			$match: {
+				'bol.status': 'Delivered',
+				approved: true
+			}
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('production-deliveries', pipeline, []);
+	});
+
+	const filters = snapshot.filters.get('production-deliveries');
+
+	assert(filters && filters.length === 1, 'Expected sanitized filter stored for production-deliveries');
+	const storedFilter = filters[0];
+
+	const serialized = JSON.stringify(storedFilter);
+	assert(!serialized.includes('bol.status'), 'Expected lookup alias fields stripped from stored filter');
+	assert(serialized.includes('type'), 'Expected base collection field retained');
+	assert(serialized.includes('approved'), 'Expected base collection field retained');
+}
+
+async function testFindQueryMetadataCaptured() {
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordDependencyResult('primary', [{ _id: 'P1' }], {
+			filter: { status: 'Active' },
+			meta: {
+				limit: 25,
+				skip: 0,
+				sort: { createdAt: -1 }
+			}
+		});
+	});
+
+	const meta = snapshot.queryMetadata.get('primary');
+
+	assert(meta && meta.length === 1, 'Expected query metadata stored for primary collection');
+	assert(meta[0].limit === 25, 'Expected limit metadata to equal 25');
+	assert(meta[0].sort && meta[0].sort.createdAt === -1, 'Expected sort metadata captured');
+}
+
+async function testAggregateMetadataCaptured() {
+	const pipeline = [
+		{$match: { status: 'Active' }},
+		{$sort: { createdAt: -1 }},
+		{$skip: 10},
+		{$limit: 5}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('primary', pipeline, []);
+	});
+
+	const meta = snapshot.queryMetadata.get('primary');
+
+	assert(meta && meta.length === 1, 'Expected aggregate metadata stored for primary collection');
+	assert(meta[0].limit === 5, 'Expected aggregate limit metadata to equal 5');
+	assert(meta[0].skip === 10, 'Expected aggregate skip metadata to equal 10');
+	assert(meta[0].sort && meta[0].sort.createdAt === -1, 'Expected aggregate sort metadata captured');
+}
+
+async function testLookupPipelineFiltersCaptured() {
+	const pipeline = [
+		{
+			$lookup: {
+				from: 'orders',
+				let: { customerId: '$customer.id' },
+				pipeline: [
+					{
+						$match: {
+							$expr: {
+								$eq: ['$id_customer', '$$customerId']
+							}
+						}
+					}
+				],
+				as: 'orders'
+			}
+		}
+	];
+
+	const result = [
+		{
+			_id: 'cust-1',
+			customer: {
+				id: 'CUST-A'
+			},
+			orders: []
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('customers', pipeline, result);
+	});
+
+	const filters = snapshot.filters.get('orders');
+
+	assert(filters && filters.length === 1, 'Expected one filter stored for orders lookup pipeline');
+	assert(filters[0].$expr && filters[0].$expr.$eq, 'Expected pipeline filter to contain $expr equality');
+	assert(filters[0].$expr.$eq[1] === 'CUST-A', 'Expected lookup pipeline filter to include substituted customer id');
+	assert(!snapshot.watchAllCollections.has('orders'), 'Expected orders collection not marked as watch-all for pipeline lookup');
+}
+
+async function testGroupPipelineMarksWatchAll() {
+	const pipeline = [
+		{$match: {status: 'Active'}},
+		{
+			$group: {
+				_id: '$type',
+				count: {$sum: 1}
+			}
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('orders', pipeline, [{_id: 'Truck', count: 3}]);
+	});
+
+	assert(snapshot.watchAllCollections.has('orders'), 'Expected grouped aggregate to mark orders as watch-all');
+}
+
+async function testLookupPipelineWithoutResolvableFiltersMarksWatchAll() {
+	const pipeline = [
+		{
+			$lookup: {
+				from: 'orders',
+				pipeline: [
+					{$sort: {createdAt: -1}},
+					{$limit: 5}
+				],
+				as: 'orders'
+			}
+		},
+		{
+			$project: {
+				orders: 0
+			}
+		}
+	];
+
+	const { snapshot } = await withDependencyTracking(async () => {
+		recordAggregateDependencies('customers', pipeline, [{_id: 'cust-1'}]);
+	});
+
+	assert(snapshot.watchAllCollections.has('orders'), 'Expected lookup collection orders marked as watch-all when alias results are unavailable');
+}
+
+async function run() {
+	await testTracksIdsFromResults();
+	await testFallsBackToWatchAllWithoutIds();
+	await testCollectsLookupDependencies();
+	await testLookupFilterStoredWhenNoMatches();
+	await testMatchFilterCapturedForPrimary();
+	await testMatchFilterIgnoresLookupAliases();
+	await testFindQueryMetadataCaptured();
+	await testAggregateMetadataCaptured();
+	await testLookupPipelineFiltersCaptured();
+	await testGroupPipelineMarksWatchAll();
+	await testLookupPipelineWithoutResolvableFiltersMarksWatchAll();
+
+	console.log('subscription dependency tests passed');
+}
+
+run().catch(err => {
+	console.error('subscription dependency tests failed');
+	console.error(err);
+	process.exit(1);
+});