Function executeQuery

packages/store/src/lib/executeQuery.ts:139–189

(
	store: StoreQueries<R>,
	typeName: TypeName,
	query: QueryExpression<Extract<R, { typeName: TypeName }>>
)

 * @public
 */
export function executeQuery<R extends UnknownRecord, TypeName extends R['typeName']>(
	store: StoreQueries<R>,
	typeName: TypeName,
	query: QueryExpression<Extract<R, { typeName: TypeName }>>
): Set<IdOf<Extract<R, { typeName: TypeName }>>> {
	type S = Extract<R, { typeName: TypeName }>

	// Extract all paths with matchers (flattens nested queries)
	const matcherPaths = extractMatcherPaths(query)

	// Build a set of matching IDs for each path
	const matchIds = Object.fromEntries(matcherPaths.map(({ path }) => [path, new Set<IdOf<S>>()]))

	// For each path, use the index to find matching IDs
	for (const { path, matcher } of matcherPaths) {
		const index = store.index(typeName, path as any)

		if ('eq' in matcher) {
			const ids = index.get().get(matcher.eq)
			if (ids) {
				for (const id of ids) {
					matchIds[path].add(id)
				}
			}
		} else if ('neq' in matcher) {
			for (const [value, ids] of index.get()) {
				if (value !== matcher.neq) {
					for (const id of ids) {
						matchIds[path].add(id)
					}
				}
			}
		} else if ('gt' in matcher) {
			for (const [value, ids] of index.get()) {
				if (typeof value === 'number' && value > matcher.gt) {
					for (const id of ids) {
						matchIds[path].add(id)
					}
				}
			}
		}

		// Short-circuit if this set is empty - intersection will be empty
		if (matchIds[path].size === 0) {
			return new Set()
		}
	}

	// Intersect all the match sets
	return intersectSets(Object.values(matchIds)) as Set<IdOf<S>>
}