@resolveio/server-lib 22.3.23 → 22.3.24

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

@@ -1,324 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,34 +0,0 @@
-{
-  "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"
-  ]
-}