Method queryTasks

src/api/TaskNotesAPI.ts:1106–1152

(
		query?: TaskNotesRuntimeTaskQuery
	)

	}

	private async queryTasks(
		query?: TaskNotesRuntimeTaskQuery
	): Promise<TaskNotesRuntimeTaskQueryResult> {
		const execution = this.normalizeRuntimeQueryForExecution(query);
		if (!execution.validation.valid) {
			throw new TaskNotesApiError("invalid_input", "TaskNotes runtime query is invalid", {
				status: 400,
				details: { issues: execution.validation.issues },
			});
		}

		const allTasks = await this.plugin.cacheManager.getAllTasks();
		const scopedTasks = applyRuntimeQueryScope(allTasks, execution.normalized.scope);
		const scopedPaths = new Set(scopedTasks.map((task) => task.path));
		const groupedTasks = await this.plugin.filterService.getGroupedTasks(execution.filterQuery);
		const matchedTasksByPath = new Map<string, TaskInfo>();

		for (const groupTasks of groupedTasks.values()) {
			for (const task of groupTasks) {
				if (scopedPaths.has(task.path) && !matchedTasksByPath.has(task.path)) {
					matchedTasksByPath.set(task.path, task);
				}
			}
		}

		const matchedTasks = Array.from(matchedTasksByPath.values());
		const offset = execution.normalized.offset;
		const limit = execution.normalized.limit;
		const returnedTasks =
			typeof limit === "number"
				? matchedTasks.slice(offset, offset + limit)
				: matchedTasks.slice(offset);
		const returnedPaths = new Set(returnedTasks.map((task) => task.path));

		return {
			tasks: returnedTasks.map(copyTaskInfo),
			total: scopedTasks.length,
			matched: matchedTasks.length,
			returned: returnedTasks.length,
			groups:
				execution.normalized.group.length > 0
					? runtimeQueryGroups(groupedTasks, returnedPaths)
					: undefined,
			query: execution.normalized,
			warnings: execution.validation.warnings,
		};
	}

	private validateRuntimeQuery(query: unknown): TaskNotesRuntimeQueryValidationResult {
		return this.normalizeRuntimeQueryForExecution(query).validation;