Method normalizeRuntimeCondition

src/api/TaskNotesAPI.ts:1298–1362

(
		condition: Record<string, unknown>,
		path: string,
		issues: TaskNotesRuntimeQueryIssue[]
	)

	}

	private normalizeRuntimeCondition(
		condition: Record<string, unknown>,
		path: string,
		issues: TaskNotesRuntimeQueryIssue[]
	): TaskNotesRuntimeNormalizedCondition | undefined {
		if (typeof condition["field"] !== "string" || condition["field"].trim().length === 0) {
			issues.push({
				path: `${path}.field`,
				code: "field_required",
				message: "Runtime query condition requires a field.",
			});
			return undefined;
		}
		const field = this.resolveRuntimeQueryField(condition["field"]);
		if (!field) {
			issues.push({
				path: `${path}.field`,
				code: "field_unknown",
				message: `Unsupported runtime query field: ${condition["field"]}`,
			});
			return undefined;
		}

		const op = normalizeRuntimeOperator(condition["op"]);
		if (!op) {
			issues.push({
				path: `${path}.op`,
				code: "operator_unknown",
				message: `Unsupported runtime query operator: ${String(condition["op"])}`,
			});
			return undefined;
		}
		if (!field.definition.supportedOperators.includes(op)) {
			issues.push({
				path: `${path}.op`,
				code: "operator_unsupported",
				message: `Operator ${op} is not supported for ${field.definition.id}.`,
			});
			return undefined;
		}

		const requiresValue = runtimeOperatorRequiresValue(op);
		if (requiresValue && typeof condition["value"] === "undefined") {
			issues.push({
				path: `${path}.value`,
				code: "value_required",
				message: `Operator ${op} requires a value.`,
			});
			return undefined;
		}
		if ((op === "in" || op === "notIn") && !Array.isArray(condition["value"])) {
			issues.push({
				path: `${path}.value`,
				code: "value_array_required",
				message: `Operator ${op} requires an array value.`,
			});
			return undefined;
		}