@resolveio/server-lib 22.3.49 → 22.3.50

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);
+});

package/tests/subscription-manager-collection-tracking.test.ts

@@ -0,0 +1,86 @@
+import { SubscriptionManager } from '../src/managers/subscription.manager';
+import { ActiveSubscriptionModel } from '../src/models/subscription.model';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function createBaseSubscription(): ActiveSubscriptionModel {
+	return {
+		publication: 'productionlocationDetailsWithId',
+		subscriptionKey: '[]',
+		subscriptionData: [],
+		collections: ['production-locations'],
+		clients: [],
+		cacheId: 0,
+		running: false,
+		runAgain: false,
+		collectionDependencies: new Map(),
+		collectionFilters: new Map(),
+		watchAllCollections: new Set(),
+		collectionQueryMeta: new Map()
+	};
+}
+
+async function testTracksRuntimeDependencies() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+
+	sub.collectionDependencies.set('truck-treating-deliveries', new Set(['TT1']));
+
+	assert(
+		manager.subscriptionReferencesCollection(sub, 'truck-treating-deliveries'),
+		'Expected dynamic dependency ids to mark collection as tracked'
+	);
+}
+
+async function testTracksFiltersAndWatchAll() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+
+	sub.collectionFilters.set('truck-treating-deliveries', [{status: 'Scheduled'}]);
+
+	assert(
+		manager.subscriptionReferencesCollection(sub, 'truck-treating-deliveries'),
+		'Expected dependency filters to mark collection as tracked'
+	);
+
+	sub.collectionFilters.clear();
+	sub.watchAllCollections.add('truck-treating-deliveries');
+
+	assert(
+		manager.subscriptionReferencesCollection(sub, 'truck-treating-deliveries'),
+		'Expected watch-all collections to be considered tracked'
+	);
+}
+
+async function testNonTrackedCollection() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+
+	assert(
+		!manager.subscriptionReferencesCollection(sub, 'truck-treating-deliveries'),
+		'Expected unrelated collections to remain untracked'
+	);
+}
+
+async function run() {
+	await testTracksRuntimeDependencies();
+	await testTracksFiltersAndWatchAll();
+	await testNonTrackedCollection();
+}
+
+run()
+	.then(() => {
+		console.log('subscription-manager-collection-tracking tests completed');
+		process.exit(0);
+	})
+	.catch(error => {
+		console.error(error);
+		process.exit(1);
+	});

package/tests/subscription-manager-invalidation.test.ts

@@ -0,0 +1,86 @@
+import { SubscriptionManager } from '../src/managers/subscription.manager';
+import { ActiveSubscriptionModel } from '../src/models/subscription.model';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function createBaseSubscription(): ActiveSubscriptionModel {
+	return {
+		publication: 'testPublication',
+		subscriptionKey: '[]',
+		subscriptionData: [],
+		collections: ['orders'],
+		clients: [],
+		cacheId: 0,
+		running: false,
+		runAgain: false,
+		collectionDependencies: new Map(),
+		collectionFilters: new Map(),
+		watchAllCollections: new Set(),
+		collectionQueryMeta: new Map()
+	};
+}
+
+async function testFilterOnlyDeleteInvalidates() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+	sub.collectionFilters.set('orders', [{status: 'Active'}]);
+
+	const shouldInvalidate = await manager.shouldInvalidateSubscription(sub, 'orders', 'delete', 'ORD-1');
+	assert(shouldInvalidate, 'Expected filter-only delete to invalidate subscription');
+}
+
+async function testFilterOnlyUpdateInvalidates() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+	sub.collectionFilters.set('orders', [{status: 'Active'}]);
+
+	const shouldInvalidate = await manager.shouldInvalidateSubscription(
+		sub,
+		'orders',
+		'update',
+		'ORD-1',
+		{_id: 'ORD-1', status: 'Archived'}
+	);
+
+	assert(shouldInvalidate, 'Expected filter-only update to invalidate subscription when tracked ids are unavailable');
+}
+
+async function testTrackedDeleteUnknownIdSkips() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+	sub.collectionDependencies.set('orders', new Set(['ORD-1']));
+
+	const shouldInvalidate = await manager.shouldInvalidateSubscription(sub, 'orders', 'delete', 'ORD-2');
+	assert(!shouldInvalidate, 'Expected delete on unknown tracked id to skip invalidation');
+}
+
+async function testTrackedDeleteKnownIdInvalidates() {
+	const manager = new SubscriptionManager() as any;
+	const sub = createBaseSubscription();
+	manager.ensureDependencyContainers(sub);
+	sub.collectionDependencies.set('orders', new Set(['ORD-1']));
+
+	const shouldInvalidate = await manager.shouldInvalidateSubscription(sub, 'orders', 'delete', 'ORD-1');
+	assert(shouldInvalidate, 'Expected delete on tracked id to invalidate subscription');
+}
+
+async function run() {
+	await testFilterOnlyDeleteInvalidates();
+	await testFilterOnlyUpdateInvalidates();
+	await testTrackedDeleteUnknownIdSkips();
+	await testTrackedDeleteKnownIdInvalidates();
+	console.log('subscription-manager-invalidation tests completed');
+	process.exit(0);
+}
+
+run().catch(error => {
+	console.error(error);
+	process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true, 
+    "inlineSources": true, 
+    "baseUrl": ".",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es5",
+    "skipLibCheck": true,
+    "stripInternal": true,
+    "noImplicitAny": false,
+    "downlevelIteration": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "lib": [
+      "es2017",
+      "dom"
+    ],
+    "noImplicitReturns": true
+  },
+  "include": [
+    "./**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/ai/assistant-core-heuristics.d.ts

@@ -1,11 +0,0 @@
-type AiAssistantCoreTermHint = {
-    terms: string[];
-    collections: string[];
-};
-export declare const AI_ASSISTANT_CORE_HEURISTICS: Readonly<{
-    version: 3;
-    collection_aliases: Record<string, string>;
-    collection_alias_options: Record<string, string[]>;
-    collection_term_hints: AiAssistantCoreTermHint[];
-}>;
-export {};